1 // Copyright 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef SYNC_SYNCABLE_ENTRY_H_ 6 #define SYNC_SYNCABLE_ENTRY_H_ 7 8 #include "sync/base/sync_export.h" 9 #include "sync/syncable/entry_kernel.h" 10 11 namespace syncer { 12 class Cryptographer; 13 class ReadNode; 14 15 namespace syncable { 16 17 class Directory; 18 class BaseTransaction; 19 20 // A read-only meta entry 21 // Instead of: 22 // Entry e = transaction.GetById(id); 23 // use: 24 // Entry e(transaction, GET_BY_ID, id); 25 // 26 // Why? The former would require a copy constructor, and it would be difficult 27 // to enforce that an entry never outlived its transaction if there were a copy 28 // constructor. 29 enum GetById { 30 GET_BY_ID 31 }; 32 33 enum GetByClientTag { 34 GET_BY_CLIENT_TAG 35 }; 36 37 enum GetByServerTag { 38 GET_BY_SERVER_TAG 39 }; 40 41 enum GetByHandle { 42 GET_BY_HANDLE 43 }; 44 45 class SYNC_EXPORT Entry { 46 public: 47 // After constructing, you must check good() to test whether the Get 48 // succeeded. 49 Entry(BaseTransaction* trans, GetByHandle, int64 handle); 50 Entry(BaseTransaction* trans, GetById, const Id& id); 51 Entry(BaseTransaction* trans, GetByServerTag, const std::string& tag); 52 Entry(BaseTransaction* trans, GetByClientTag, const std::string& tag); 53 54 bool good() const { return 0 != kernel_; } 55 56 BaseTransaction* trans() const { return basetrans_; } 57 58 // Field accessors. 59 inline int64 Get(MetahandleField field) const { 60 DCHECK(kernel_); 61 return kernel_->ref(field); 62 } 63 inline Id Get(IdField field) const { 64 DCHECK(kernel_); 65 return kernel_->ref(field); 66 } 67 inline int64 Get(Int64Field field) const { 68 DCHECK(kernel_); 69 return kernel_->ref(field); 70 } 71 inline const base::Time& Get(TimeField field) const { 72 DCHECK(kernel_); 73 return kernel_->ref(field); 74 } 75 inline int64 Get(BaseVersion field) const { 76 DCHECK(kernel_); 77 return kernel_->ref(field); 78 } 79 inline bool Get(IndexedBitField field) const { 80 DCHECK(kernel_); 81 return kernel_->ref(field); 82 } 83 inline bool Get(IsDelField field) const { 84 DCHECK(kernel_); 85 return kernel_->ref(field); 86 } 87 inline bool Get(BitField field) const { 88 DCHECK(kernel_); 89 return kernel_->ref(field); 90 } 91 const std::string& Get(StringField field) const; 92 inline const sync_pb::EntitySpecifics& Get(ProtoField field) const { 93 DCHECK(kernel_); 94 return kernel_->ref(field); 95 } 96 inline const UniquePosition& Get(UniquePositionField field) const { 97 DCHECK(kernel_); 98 return kernel_->ref(field); 99 } 100 inline bool Get(BitTemp field) const { 101 DCHECK(kernel_); 102 return kernel_->ref(field); 103 } 104 105 ModelType GetServerModelType() const; 106 ModelType GetModelType() const; 107 108 Id GetPredecessorId() const; 109 Id GetSuccessorId() const; 110 Id GetFirstChildId() const; 111 int GetTotalNodeCount() const; 112 113 int GetPositionIndex() const; 114 115 // Returns a vector of this node's children's handles. 116 // Clears |result| if there are no children. If this node is of a type that 117 // supports user-defined ordering then the resulting vector will be in the 118 // proper order. 119 void GetChildHandles(std::vector<int64>* result) const; 120 121 inline bool ExistsOnClientBecauseNameIsNonEmpty() const { 122 DCHECK(kernel_); 123 return !kernel_->ref(NON_UNIQUE_NAME).empty(); 124 } 125 126 inline bool IsRoot() const { 127 DCHECK(kernel_); 128 return kernel_->ref(ID).IsRoot(); 129 } 130 131 // Returns true if this is an entry that is expected to maintain a certain 132 // sort ordering relative to its siblings under the same parent. 133 bool ShouldMaintainPosition() const; 134 135 Directory* dir() const; 136 137 const EntryKernel GetKernelCopy() const { 138 return *kernel_; 139 } 140 141 // Dumps all entry info into a DictionaryValue and returns it. 142 // Transfers ownership of the DictionaryValue to the caller. 143 base::DictionaryValue* ToValue(Cryptographer* cryptographer) const; 144 145 protected: // Don't allow creation on heap, except by sync API wrappers. 146 void* operator new(size_t size) { return (::operator new)(size); } 147 148 inline explicit Entry(BaseTransaction* trans) 149 : basetrans_(trans), 150 kernel_(NULL) { } 151 152 protected: 153 BaseTransaction* const basetrans_; 154 155 EntryKernel* kernel_; 156 157 private: 158 friend class Directory; 159 friend class syncer::ReadNode; 160 friend std::ostream& operator << (std::ostream& s, const Entry& e); 161 162 DISALLOW_COPY_AND_ASSIGN(Entry); 163 }; 164 165 std::ostream& operator<<(std::ostream& os, const Entry& entry); 166 167 } // namespace syncable 168 } // namespace syncer 169 170 #endif // SYNC_SYNCABLE_ENTRY_H_ 171