EntryKernel: change from assignable refs to puts.

chrome/browser/sync/syncable/syncable.h

 // Copyright (c) 2009 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 CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 
 #include <algorithm>
 #include <bitset>
 #include <iosfwd>
@@ skipping 203 matching lines @@
 
 enum CreateNewUpdateItem {
   CREATE_NEW_UPDATE_ITEM
 };
 
 typedef std::set<std::string> AttributeKeySet;
 
 // Why the singular enums?  So the code compile-time dispatches instead of
 // runtime dispatches as it would with a single enum and an if() statement.
 
-// The EntryKernel class contains the actual data for an entry.  It
-// would be a private class, except the number of required friend
-// declarations would bloat the code.
+// The EntryKernel class contains the actual data for an entry.
 struct EntryKernel {
- protected:
+ private:
   std::string string_fields[STRING_FIELDS_COUNT];
   Blob blob_fields[BLOB_FIELDS_COUNT];
   int64 int64_fields[INT64_FIELDS_COUNT];
   Id id_fields[ID_FIELDS_COUNT];
   std::bitset<BIT_FIELDS_COUNT> bit_fields;
   std::bitset<BIT_TEMPS_COUNT> bit_temps;
 
  public:
   inline void mark_dirty() {
     dirty_ = true;
   }
 
   inline void clear_dirty() {
     dirty_ = false;
   }
 
   inline bool is_dirty() const {
     return dirty_;
   }
 
-  // Contain all this error-prone arithmetic in one place.
-  inline int64& ref(MetahandleField field) {
-    return int64_fields[field - INT64_FIELDS_BEGIN];
+  // Setters.
+  inline void put(MetahandleField field, int64 value) {
+    int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
-  inline int64& ref(Int64Field field) {
-    return int64_fields[field - INT64_FIELDS_BEGIN];
+  inline void put(Int64Field field, int64 value) {
+    int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
-  inline Id& ref(IdField field) {
-    return id_fields[field - ID_FIELDS_BEGIN];
+  inline void put(IdField field, const Id& value) {
+    id_fields[field - ID_FIELDS_BEGIN] = value;
   }
-  inline int64& ref(BaseVersion field) {
-    return int64_fields[field - INT64_FIELDS_BEGIN];
+  inline void put(BaseVersion field, int64 value) {
+    int64_fields[field - INT64_FIELDS_BEGIN] = value;
   }
-  inline std::bitset<BIT_FIELDS_COUNT>::reference ref(IndexedBitField field) {
-    return bit_fields[field - BIT_FIELDS_BEGIN];
+  inline void put(IndexedBitField field, bool value) {
+    bit_fields[field - BIT_FIELDS_BEGIN] = value;
   }
-  inline std::bitset<BIT_FIELDS_COUNT>::reference ref(IsDelField field) {
-    return bit_fields[field - BIT_FIELDS_BEGIN];
+  inline void put(IsDelField field, bool value) {
+    bit_fields[field - BIT_FIELDS_BEGIN] = value;
   }
-  inline std::bitset<BIT_FIELDS_COUNT>::reference ref(BitField field) {
-    return bit_fields[field - BIT_FIELDS_BEGIN];
+  inline void put(BitField field, bool value) {
+    bit_fields[field - BIT_FIELDS_BEGIN] = value;
   }
-  inline std::string& ref(StringField field) {
-    return string_fields[field - STRING_FIELDS_BEGIN];
+  inline void put(StringField field, const std::string& value) {
+    string_fields[field - STRING_FIELDS_BEGIN] = value;
   }
-  inline Blob& ref(BlobField field) {
-    return blob_fields[field - BLOB_FIELDS_BEGIN];
+  inline void put(BlobField field, const Blob& value) {
+    blob_fields[field - BLOB_FIELDS_BEGIN] = value;
   }
-  inline std::bitset<BIT_TEMPS_COUNT>::reference ref(BitTemp field) {
-    return bit_temps[field - BIT_TEMPS_BEGIN];
+  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];
   }
   inline const Id& ref(IdField field) const {
     return id_fields[field - ID_FIELDS_BEGIN];
   }
   inline int64 ref(BaseVersion field) const {
@@ skipping 11 matching lines @@
   inline const std::string& ref(StringField field) const {
     return string_fields[field - STRING_FIELDS_BEGIN];
   }
   inline const Blob& ref(BlobField field) const {
     return blob_fields[field - BLOB_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 Blob& mutable_ref(BlobField field) {
+    return blob_fields[field - BLOB_FIELDS_BEGIN];
+  }
+  inline Id& mutable_ref(IdField field) {
+    return id_fields[field - ID_FIELDS_BEGIN];
+  }
  private:
   // Tracks whether this entry needs to be saved to the database.
   bool dirty_;
 };
 
 // A read-only meta entry.
 class Entry {
   friend class Directory;
   friend std::ostream& ::operator << (std::ostream& s, const Entry& e);
 
@@ skipping 133 matching lines @@
   inline bool Put(BitTemp field, bool value) {
     return PutTemp(field, value);
   }
 
  protected:
 
   template <typename FieldType, typename ValueType>
   inline bool PutField(FieldType field, const ValueType& value) {
     DCHECK(kernel_);
     if (kernel_->ref(field) != value) {
-      kernel_->ref(field) = value;
+      kernel_->put(field, value);
       kernel_->mark_dirty();
     }
     return true;
   }
 
   template <typename TempType, typename ValueType>
   inline bool PutTemp(TempType field, const ValueType& value) {
     DCHECK(kernel_);
-    kernel_->ref(field) = value;
+    kernel_->put(field, value);
     return true;
   }
 
   bool PutIsDel(bool value);
 
  private:  // Don't allow creation on heap, except by sync API wrappers.
   friend class sync_api::WriteNode;
   void* operator new(size_t size) { return (::operator new)(size); }
 
   bool PutImpl(StringField field, const std::string& value);
@@ skipping 587 matching lines @@
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 browser_sync::FastDump& operator <<
   (browser_sync::FastDump&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_