sync/syncable/entry.h

   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   // Server tagged items are deprecated for all types but bookmarks.
  39   GET_BY_SERVER_TAG
  40 };
  41
  42 enum GetTypeRoot {
  43   GET_TYPE_ROOT
  44 };
  45
  46 enum GetByHandle {
  47   GET_BY_HANDLE
  48 };
  49
  50 class SYNC_EXPORT Entry {
  51  public:
  52   // After constructing, you must check good() to test whether the Get
  53   // succeeded.
  54   Entry(BaseTransaction* trans, GetByHandle, int64 handle);
  55   Entry(BaseTransaction* trans, GetById, const Id& id);
  56   Entry(BaseTransaction* trans, GetTypeRoot, ModelType type);
  57   Entry(BaseTransaction* trans, GetByClientTag, const std::string& tag);
  58
  59   // This lookup function is deprecated.  All types except bookmarks can use
  60   // the GetTypeRoot variant instead.
  61   Entry(BaseTransaction* trans, GetByServerTag, const std::string& tag);
  62
  63   bool good() const { return 0 != kernel_; }
  64
  65   BaseTransaction* trans() const { return basetrans_; }
  66
  67   // Field accessors.
  68   int64 GetMetahandle() const {
  69     DCHECK(kernel_);
  70     return kernel_->ref(META_HANDLE);
  71   }
  72
  73   int64 GetBaseVersion() const {
  74     DCHECK(kernel_);
  75     return kernel_->ref(BASE_VERSION);
  76   }
  77
  78   int64 GetServerVersion() const {
  79     DCHECK(kernel_);
  80     return kernel_->ref(SERVER_VERSION);
  81   }
  82
  83   int64 GetLocalExternalId() const {
  84     DCHECK(kernel_);
  85     return kernel_->ref(LOCAL_EXTERNAL_ID);
  86   }
  87
  88   int64 GetTransactionVersion() const {
  89     DCHECK(kernel_);
  90     return kernel_->ref(TRANSACTION_VERSION);
  91   }
  92
  93   const base::Time& GetMtime() const {
  94     DCHECK(kernel_);
  95     return kernel_->ref(MTIME);
  96   }
  97
  98   const base::Time& GetServerMtime() const {
  99     DCHECK(kernel_);
 100     return kernel_->ref(SERVER_MTIME);
 101   }
 102
 103   const base::Time& GetCtime() const {
 104     DCHECK(kernel_);
 105     return kernel_->ref(CTIME);
 106   }
 107
 108   const base::Time& GetServerCtime() const {
 109     DCHECK(kernel_);
 110     return kernel_->ref(SERVER_CTIME);
 111   }
 112
 113   Id GetId() const {
 114     DCHECK(kernel_);
 115     return kernel_->ref(ID);
 116   }
 117
 118   Id GetParentId() const {
 119     DCHECK(kernel_);
 120     return kernel_->ref(PARENT_ID);
 121   }
 122
 123   Id GetServerParentId() const {
 124     DCHECK(kernel_);
 125     return kernel_->ref(SERVER_PARENT_ID);
 126   }
 127
 128   bool GetIsUnsynced() const {
 129     DCHECK(kernel_);
 130     return kernel_->ref(IS_UNSYNCED);
 131   }
 132
 133   bool GetIsUnappliedUpdate() const {
 134     DCHECK(kernel_);
 135     return kernel_->ref(IS_UNAPPLIED_UPDATE);
 136   }
 137
 138   bool GetIsDel() const {
 139     DCHECK(kernel_);
 140     return kernel_->ref(IS_DEL);
 141   }
 142
 143   bool GetIsDir() const {
 144     DCHECK(kernel_);
 145     return kernel_->ref(IS_DIR);
 146   }
 147
 148   bool GetServerIsDir() const {
 149     DCHECK(kernel_);
 150     return kernel_->ref(SERVER_IS_DIR);
 151   }
 152
 153   bool GetServerIsDel() const {
 154     DCHECK(kernel_);
 155     return kernel_->ref(SERVER_IS_DEL);
 156   }
 157
 158   const std::string& GetNonUniqueName() const {
 159     DCHECK(kernel_);
 160     return kernel_->ref(NON_UNIQUE_NAME);
 161   }
 162
 163   const std::string& GetServerNonUniqueName() const {
 164     DCHECK(kernel_);
 165     return kernel_->ref(SERVER_NON_UNIQUE_NAME);
 166   }
 167
 168   const std::string& GetUniqueServerTag() const {
 169     DCHECK(kernel_);
 170     return kernel_->ref(UNIQUE_SERVER_TAG);
 171   }
 172
 173   const std::string& GetUniqueClientTag() const {
 174     DCHECK(kernel_);
 175     return kernel_->ref(UNIQUE_CLIENT_TAG);
 176   }
 177
 178   const std::string& GetUniqueBookmarkTag() const {
 179     DCHECK(kernel_);
 180     return kernel_->ref(UNIQUE_BOOKMARK_TAG);
 181   }
 182
 183   const sync_pb::EntitySpecifics& GetSpecifics() const {
 184     DCHECK(kernel_);
 185     return kernel_->ref(SPECIFICS);
 186   }
 187
 188   const sync_pb::EntitySpecifics& GetServerSpecifics() const {
 189     DCHECK(kernel_);
 190     return kernel_->ref(SERVER_SPECIFICS);
 191   }
 192
 193   const sync_pb::EntitySpecifics& GetBaseServerSpecifics() const {
 194     DCHECK(kernel_);
 195     return kernel_->ref(BASE_SERVER_SPECIFICS);
 196   }
 197
 198   const UniquePosition& GetServerUniquePosition() const {
 199     DCHECK(kernel_);
 200     return kernel_->ref(SERVER_UNIQUE_POSITION);
 201   }
 202
 203   const UniquePosition& GetUniquePosition() const {
 204     DCHECK(kernel_);
 205     return kernel_->ref(UNIQUE_POSITION);
 206   }
 207
 208   const sync_pb::AttachmentMetadata& GetAttachmentMetadata() const {
 209     DCHECK(kernel_);
 210     return kernel_->ref(ATTACHMENT_METADATA);
 211   }
 212
 213   const sync_pb::AttachmentMetadata& GetServerAttachmentMetadata() const {
 214     DCHECK(kernel_);
 215     return kernel_->ref(SERVER_ATTACHMENT_METADATA);
 216   }
 217
 218   bool GetSyncing() const;
 219   bool GetDirtySync() const ;
 220
 221   ModelType GetServerModelType() const;
 222   ModelType GetModelType() const;
 223
 224   Id GetPredecessorId() const;
 225   Id GetSuccessorId() const;
 226   Id GetFirstChildId() const;
 227   int GetTotalNodeCount() const;
 228
 229   int GetPositionIndex() const;
 230
 231   // Returns a vector of this node's children's handles.
 232   // Clears |result| if there are no children.  If this node is of a type that
 233   // supports user-defined ordering then the resulting vector will be in the
 234   // proper order.
 235   void GetChildHandles(std::vector<int64>* result) const;
 236
 237   inline bool ExistsOnClientBecauseNameIsNonEmpty() const {
 238     DCHECK(kernel_);
 239     return !kernel_->ref(NON_UNIQUE_NAME).empty();
 240   }
 241
 242   inline bool IsRoot() const {
 243     DCHECK(kernel_);
 244     return kernel_->ref(ID).IsRoot();
 245   }
 246
 247   // Returns true if this is an entry that is expected to maintain a certain
 248   // sort ordering relative to its siblings under the same parent.
 249   bool ShouldMaintainPosition() const;
 250
 251   // Returns true if this is an entry that is expected to maintain hierarchy.
 252   // ie. Whether or not the PARENT_ID field contains useful information.
 253   bool ShouldMaintainHierarchy() const;
 254
 255   Directory* dir() const;
 256
 257   const EntryKernel GetKernelCopy() const {
 258     return *kernel_;
 259   }
 260
 261   // Dumps all entry info into a DictionaryValue and returns it.
 262   // Transfers ownership of the DictionaryValue to the caller.
 263   base::DictionaryValue* ToValue(Cryptographer* cryptographer) const;
 264
 265  protected:  // Don't allow creation on heap, except by sync API wrappers.
 266   void* operator new(size_t size) { return (::operator new)(size); }
 267
 268   inline explicit Entry(BaseTransaction* trans)
 269       : basetrans_(trans),
 270         kernel_(NULL) { }
 271
 272  protected:
 273   BaseTransaction* const basetrans_;
 274
 275   EntryKernel* kernel_;
 276
 277  private:
 278   friend class Directory;
 279   friend class syncer::ReadNode;
 280   friend std::ostream& operator << (std::ostream& s, const Entry& e);
 281
 282   DISALLOW_COPY_AND_ASSIGN(Entry);
 283 };
 284
 285 std::ostream& operator<<(std::ostream& os, const Entry& entry);
 286
 287 }  // namespace syncable
 288 }  // namespace syncer
 289
 290 #endif  // SYNC_SYNCABLE_ENTRY_H_