Changed DB to store node positions as Ordinals.

sync/syncable/entry_kernel.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef SYNC_SYNCABLE_ENTRY_KERNEL_H_
 #define SYNC_SYNCABLE_ENTRY_KERNEL_H_
 
 #include "base/time.h"
 #include "base/values.h"
 #include "sync/internal_api/public/base/model_type.h"
+#include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/internal_api/public/util/immutable.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/metahandle_set.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/util/time.h"
 
 namespace syncer {
 namespace syncable {
 
 // Things you need to update if you change any of the fields below:
 //  - EntryKernel struct in this file
 //  - syncable_columns.h
 //  - syncable_enum_conversions{.h,.cc,_unittest.cc}
-//  - EntryKernel::EntryKernel(), EntryKernel::ToValue(), operator<<
-//    for Entry in syncable.cc
+//  - EntryKernel::EntryKernel(), EntryKernel::ToValue() in entry_kernel.cc
+//  - operator<< in Entry.cc
 //  - BindFields() and UnpackEntry() in directory_backing_store.cc
 //  - TestSimpleFieldsPreservedDuringSaveChanges in syncable_unittest.cc
 
 static const int64 kInvalidMetaHandle = 0;
 
 enum {
   BEGIN_FIELDS = 0,
   INT64_FIELDS_BEGIN = BEGIN_FIELDS
 };
 
 enum MetahandleField {
   // Primary key into the table.  Keep this as a handle to the meta entry
   // across transactions.
   META_HANDLE = INT64_FIELDS_BEGIN
 };
 
 enum BaseVersion {
   // After initial upload, the version is controlled by the server, and is
   // increased whenever the data or metadata changes on the server.
   BASE_VERSION = META_HANDLE + 1,
 };
 
 enum Int64Field {
   SERVER_VERSION = BASE_VERSION + 1,
-
-  // A numeric position value that indicates the relative ordering of
-  // this object among its siblings.
-  SERVER_POSITION_IN_PARENT,
-
   LOCAL_EXTERNAL_ID,  // ID of an item in the external local storage that this
                       // entry is associated with. (such as bookmarks.js)
-
   INT64_FIELDS_END
 };
 
 enum {
   INT64_FIELDS_COUNT = INT64_FIELDS_END - INT64_FIELDS_BEGIN,
   TIME_FIELDS_BEGIN = INT64_FIELDS_END,
 };
 
 enum TimeField {
   MTIME = TIME_FIELDS_BEGIN,
@@ skipping 68 matching lines @@
 // From looking at the sqlite3 docs, it's not directly stated, but it
 // seems the overhead for storing a NULL blob is very small.
 enum ProtoField {
   SPECIFICS = PROTO_FIELDS_BEGIN,
   SERVER_SPECIFICS,
   BASE_SERVER_SPECIFICS,
   PROTO_FIELDS_END,
 };
 
 enum {
-  FIELD_COUNT = PROTO_FIELDS_END,
+  PROTO_FIELDS_COUNT = PROTO_FIELDS_END - PROTO_FIELDS_BEGIN,
+  ORDINAL_FIELDS_BEGIN = PROTO_FIELDS_END
+};
+
+enum OrdinalField {
+  // An Ordinal that identifies the relative ordering of this object
+  // among its siblings.
+  SERVER_ORDINAL_IN_PARENT = ORDINAL_FIELDS_BEGIN,
+  ORDINAL_FIELDS_END
+};
+
+enum {
+  ORDINAL_FIELDS_COUNT = ORDINAL_FIELDS_END - ORDINAL_FIELDS_BEGIN,
+  END_FIELDS = ORDINAL_FIELDS_END,

[rlarocque, 2012/10/08 20:48:38]

Is it necessary to have both FIELD_COUNT and END_FIELDS?

+  FIELD_COUNT = END_FIELDS,
   // Past this point we have temporaries, stored in memory only.
-  BEGIN_TEMPS = PROTO_FIELDS_END,
+  BEGIN_TEMPS = ORDINAL_FIELDS_END,
   BIT_TEMPS_BEGIN = BEGIN_TEMPS,
 };
 
 enum BitTemp {
   // Not to be confused with IS_UNSYNCED, this bit is used to detect local
   // changes to items that happen during the server Commit operation.
   SYNCING = BIT_TEMPS_BEGIN,
   BIT_TEMPS_END,
 };
 
 enum {
   BIT_TEMPS_COUNT = BIT_TEMPS_END - BIT_TEMPS_BEGIN
 };
 
-enum {
-  PROTO_FIELDS_COUNT = PROTO_FIELDS_END - PROTO_FIELDS_BEGIN
-};
 
 
 struct EntryKernel {
  private:
   std::string string_fields[STRING_FIELDS_COUNT];
   sync_pb::EntitySpecifics specifics_fields[PROTO_FIELDS_COUNT];
   int64 int64_fields[INT64_FIELDS_COUNT];
   base::Time time_fields[TIME_FIELDS_COUNT];
   Id id_fields[ID_FIELDS_COUNT];
+  NodeOrdinal ordinal_fields[ORDINAL_FIELDS_COUNT];
   std::bitset<BIT_FIELDS_COUNT> bit_fields;
   std::bitset<BIT_TEMPS_COUNT> bit_temps;
 
  public:
   EntryKernel();
   ~EntryKernel();
 
   // Set the dirty bit, and optionally add this entry's metahandle to
   // a provided index on dirty bits in |dirty_index|. Parameter may be null,
   // and will result only in setting the dirty bit of this entry.
@@ skipping 47 matching lines @@
   }
   inline void put(BitField field, bool value) {
     bit_fields[field - BIT_FIELDS_BEGIN] = value;
   }
   inline void put(StringField field, const std::string& value) {
     string_fields[field - STRING_FIELDS_BEGIN] = value;
   }
   inline void put(ProtoField field, const sync_pb::EntitySpecifics& value) {
     specifics_fields[field - PROTO_FIELDS_BEGIN].CopyFrom(value);
   }
+  inline void put(OrdinalField field, const NodeOrdinal& value) {
+    ordinal_fields[field - ORDINAL_FIELDS_BEGIN] = value;
+  }
   inline void put(BitTemp field, bool value) {
     bit_temps[field - BIT_TEMPS_BEGIN] = value;
   }
 
   // Const ref getters.
   inline int64 ref(MetahandleField field) const {
     return int64_fields[field - INT64_FIELDS_BEGIN];
   }
   inline int64 ref(Int64Field field) const {
     return int64_fields[field - INT64_FIELDS_BEGIN];
@@ skipping 15 matching lines @@
   }
   inline bool ref(BitField field) const {
     return bit_fields[field - BIT_FIELDS_BEGIN];
   }
   inline const std::string& ref(StringField field) const {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline const sync_pb::EntitySpecifics& ref(ProtoField field) const {
     return specifics_fields[field - PROTO_FIELDS_BEGIN];
   }
+  inline const NodeOrdinal& ref(OrdinalField field) const {
+    return ordinal_fields[field - ORDINAL_FIELDS_BEGIN];
+  }
   inline bool ref(BitTemp field) const {
     return bit_temps[field - BIT_TEMPS_BEGIN];
   }
 
   // Non-const, mutable ref getters for object types only.
   inline std::string& mutable_ref(StringField field) {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline sync_pb::EntitySpecifics& mutable_ref(ProtoField field) {
     return specifics_fields[field - PROTO_FIELDS_BEGIN];
   }
   inline Id& mutable_ref(IdField field) {
     return id_fields[field - ID_FIELDS_BEGIN];
   }
+  inline NodeOrdinal& mutable_ref(OrdinalField field) {
+    return ordinal_fields[field - ORDINAL_FIELDS_BEGIN];
+  }
 
   ModelType GetServerModelType() const;
 
   // Dumps all kernel info into a DictionaryValue and returns it.
   // Transfers ownership of the DictionaryValue to the caller.
   base::DictionaryValue* ToValue() const;
 
  private:
   // Tracks whether this entry needs to be saved to the database.
   bool dirty_;
@@ skipping 12 matching lines @@
     const EntryKernelMutation& mutation);
 
 // Caller owns the return value.
 base::ListValue* EntryKernelMutationMapToValue(
     const EntryKernelMutationMap& mutations);
 
 }  // namespace syncable
 }  // namespace syncer
 
 #endif // SYNC_SYNCABLE_ENTRY_KERNEL_H_