Use more conventional field order in Mutation

ApiTest.cpp

@@ -17,9 +17,9 @@ void setAndClearPrev() {
     const int64_t k = __builtin_bswap64(version);
     const int64_t zero = __builtin_bswap64(0);
     weaselab::VersionedMap::Mutation m[] = {
-        {(const uint8_t *)&zero, (const uint8_t *)&k, 8, 8,
+        {(const uint8_t *)&zero, 8, (const uint8_t *)&k, 8,
          weaselab::VersionedMap::Clear},
-        {(const uint8_t *)&k, (const uint8_t *)&k, 8, 8,
+        {(const uint8_t *)&k, 8, (const uint8_t *)&k, 8,
          weaselab::VersionedMap::Set},
     };
     versionedMap.addMutations(m, sizeof(m) / sizeof(m[0]), version);

Bench.cpp

@@ -14,9 +14,9 @@ void monotonicallyIncreasing() {
     const int64_t remove = __builtin_bswap64(facade.getVersion() - kWindow);
     const int64_t next = __builtin_bswap64(facade.getVersion());
     weaselab::VersionedMap::Mutation mutations[] = {
-        {(const uint8_t *)&remove, nullptr, 8, 0,
+        {(const uint8_t *)&remove, 8, nullptr, 0,
          weaselab::VersionedMap::Clear},
-        {(const uint8_t *)&next, (const uint8_t *)&next, 8, 8,
+        {(const uint8_t *)&next, 8, (const uint8_t *)&next, 8,
          weaselab::VersionedMap::Set},
     };
     facade.addMutations(mutations, sizeof(mutations) / sizeof(mutations[0]),

FacadeFuzz.cpp

@@ -164,20 +164,20 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
         case 0: {
           // Point write
           auto val = randomKey(arena);
-          mutations.push_back({keys[i].p, val.p, keys[i].len, val.len,
+          mutations.push_back({keys[i].p, keys[i].len, val.p, val.len,
                                weaselab::VersionedMap::Set});
           ++i;
         } break;
         case 1: {
           // Point clear
-          mutations.push_back({keys[i].p, nullptr, keys[i].len, 0,
+          mutations.push_back({keys[i].p, keys[i].len, nullptr, 0,
                                weaselab::VersionedMap::Clear});
           ++i;
         } break;
         case 2: {
           // Range clear
           if (i + 1 < int(keys.size())) {
-            mutations.push_back({keys[i].p, keys[i + 1].p, keys[i].len,
+            mutations.push_back({keys[i].p, keys[i].len, keys[i + 1].p,
                                  keys[i + 1].len,
                                  weaselab::VersionedMap::Clear});
             i += 2;

FacadeTest.cpp

@@ -13,16 +13,16 @@ inline String operator"" _s(const char *str, size_t size) {
 
 weaselab::VersionedMap::Mutation set(weaselab::VersionedMap::Key k,
                                      weaselab::VersionedMap::Key v) {
-  return {k.p, v.p, k.len, v.len, weaselab::VersionedMap::Set};
+  return {k.p, k.len, v.p, v.len, weaselab::VersionedMap::Set};
 }
 
 weaselab::VersionedMap::Mutation clear(weaselab::VersionedMap::Key k) {
-  return {k.p, nullptr, k.len, 0, weaselab::VersionedMap::Clear};
+  return {k.p, k.len, nullptr, 0, weaselab::VersionedMap::Clear};
 }
 
 weaselab::VersionedMap::Mutation clear(weaselab::VersionedMap::Key begin,
                                        weaselab::VersionedMap::Key end) {
-  return {begin.p, end.p, begin.len, end.len, weaselab::VersionedMap::Clear};
+  return {begin.p, begin.len, end.p, end.len, weaselab::VersionedMap::Clear};
 }
 
 void breakpoint_me() {}

FdbVersionedMap.cpp

@@ -1235,7 +1235,7 @@ struct __attribute__((__visibility__("hidden"))) VersionedMap::Impl {
       }
 
       verUpdateRef.mutations.push_back(
-          Mutation{param1.p, param2.p, param1.len, param2.len, m.type});
+          Mutation{param1.p, param1.len, param2.p, param2.len, m.type});
     }
   }
 

VersionedMap.cpp

@@ -1488,26 +1488,26 @@ int main() {
     printf("Bytes: %" PRId64 "\n", versionedMap.getBytes());
     {
       weaselab::VersionedMap::Mutation m[] = {
-          {(const uint8_t *)"a", nullptr, 1, 0, weaselab::VersionedMap::Set},
+          {(const uint8_t *)"a", 1, nullptr, 0, weaselab::VersionedMap::Set},
-          {(const uint8_t *)"b", nullptr, 1, 0, weaselab::VersionedMap::Set},
+          {(const uint8_t *)"b", 1, nullptr, 0, weaselab::VersionedMap::Set},
-          {(const uint8_t *)"c", nullptr, 1, 0, weaselab::VersionedMap::Set},
+          {(const uint8_t *)"c", 1, nullptr, 0, weaselab::VersionedMap::Set},
-          {(const uint8_t *)"d", nullptr, 1, 0, weaselab::VersionedMap::Set},
+          {(const uint8_t *)"d", 1, nullptr, 0, weaselab::VersionedMap::Set},
-          {(const uint8_t *)"e", nullptr, 1, 0, weaselab::VersionedMap::Set},
+          {(const uint8_t *)"e", 1, nullptr, 0, weaselab::VersionedMap::Set},
-          {(const uint8_t *)"f", nullptr, 1, 0, weaselab::VersionedMap::Set},
+          {(const uint8_t *)"f", 1, nullptr, 0, weaselab::VersionedMap::Set},
       };
       versionedMap.addMutations(m, sizeof(m) / sizeof(m[0]), 1);
     }
     printf("Bytes: %" PRId64 "\n", versionedMap.getBytes());
     {
       weaselab::VersionedMap::Mutation m[] = {
-          {(const uint8_t *)"a", (const uint8_t *)"d", 1, 1,
+          {(const uint8_t *)"a", 1, (const uint8_t *)"d", 1,
            weaselab::VersionedMap::Clear},
       };
       versionedMap.addMutations(m, sizeof(m) / sizeof(m[0]), 2);
     }
     {
       weaselab::VersionedMap::Mutation m[] = {
-          {(const uint8_t *)"b", (const uint8_t *)"", 1, 0,
+          {(const uint8_t *)"b", 1, (const uint8_t *)"", 0,
            weaselab::VersionedMap::Clear},
       };
       versionedMap.addMutations(m, sizeof(m) / sizeof(m[0]), 3);

include/VersionedMap.h

@@ -60,8 +60,8 @@ struct __attribute__((__visibility__("default"))) VersionedMap {
   /** Mutations are bitwise-lexicographically ordered by param1. */
   struct Mutation {
     const uint8_t *param1;
-    const uint8_t *param2;
     int param1Len;
+    const uint8_t *param2;
     int param2Len;
     MutationType type;
   };