storage/common/data_element.h

   1 // Copyright 2013 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 STORAGE_COMMON_DATA_ELEMENT_H_
   6 #define STORAGE_COMMON_DATA_ELEMENT_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/files/file_path.h"
  13 #include "base/logging.h"
  14 #include "base/time/time.h"
  15 #include "storage/common/storage_common_export.h"
  16 #include "url/gurl.h"
  17
  18 namespace storage {
  19
  20 // Represents a base Web data element. This could be either one of
  21 // bytes, file or blob data.
  22 class STORAGE_COMMON_EXPORT DataElement {
  23  public:
  24   enum Type {
  25     TYPE_UNKNOWN = -1,
  26     TYPE_BYTES,
  27     TYPE_FILE,
  28     TYPE_BLOB,
  29     TYPE_FILE_FILESYSTEM,
  30   };
  31
  32   DataElement();
  33   ~DataElement();
  34
  35   Type type() const { return type_; }
  36   const char* bytes() const { return bytes_ ? bytes_ : &buf_[0]; }
  37   const base::FilePath& path() const { return path_; }
  38   const GURL& filesystem_url() const { return filesystem_url_; }
  39   const std::string& blob_uuid() const { return blob_uuid_; }
  40   uint64 offset() const { return offset_; }
  41   uint64 length() const { return length_; }
  42   const base::Time& expected_modification_time() const {
  43     return expected_modification_time_;
  44   }
  45
  46   // Sets TYPE_BYTES data. This copies the given data into the element.
  47   void SetToBytes(const char* bytes, int bytes_len) {
  48     type_ = TYPE_BYTES;
  49     buf_.assign(bytes, bytes + bytes_len);
  50     length_ = buf_.size();
  51   }
  52
  53   // Sets TYPE_BYTES data. This does NOT copy the given data and the caller
  54   // should make sure the data is alive when this element is accessed.
  55   void SetToSharedBytes(const char* bytes, int bytes_len) {
  56     type_ = TYPE_BYTES;
  57     bytes_ = bytes;
  58     length_ = bytes_len;
  59   }
  60
  61   // Sets TYPE_FILE data.
  62   void SetToFilePath(const base::FilePath& path) {
  63     SetToFilePathRange(path, 0, kuint64max, base::Time());
  64   }
  65
  66   // Sets TYPE_BLOB data.
  67   void SetToBlob(const std::string& uuid) {
  68     SetToBlobRange(uuid, 0, kuint64max);
  69   }
  70
  71   // Sets TYPE_FILE data with range.
  72   void SetToFilePathRange(const base::FilePath& path,
  73                           uint64 offset, uint64 length,
  74                           const base::Time& expected_modification_time);
  75
  76   // Sets TYPE_BLOB data with range.
  77   void SetToBlobRange(const std::string& blob_uuid,
  78                       uint64 offset, uint64 length);
  79
  80   // Sets TYPE_FILE_FILESYSTEM with range.
  81   void SetToFileSystemUrlRange(const GURL& filesystem_url,
  82                                uint64 offset, uint64 length,
  83                                const base::Time& expected_modification_time);
  84
  85  private:
  86   Type type_;
  87   std::vector<char> buf_;  // For TYPE_BYTES.
  88   const char* bytes_;  // For TYPE_BYTES.
  89   base::FilePath path_;  // For TYPE_FILE.
  90   GURL filesystem_url_;  // For TYPE_FILE_FILESYSTEM.
  91   std::string blob_uuid_;
  92   uint64 offset_;
  93   uint64 length_;
  94   base::Time expected_modification_time_;
  95 };
  96
  97 #if defined(UNIT_TEST)
  98 inline bool operator==(const DataElement& a, const DataElement& b) {
  99   if (a.type() != b.type() ||
 100       a.offset() != b.offset() ||
 101       a.length() != b.length())
 102     return false;
 103   switch (a.type()) {
 104     case DataElement::TYPE_BYTES:
 105       return memcmp(a.bytes(), b.bytes(), b.length()) == 0;
 106     case DataElement::TYPE_FILE:
 107       return a.path() == b.path() &&
 108              a.expected_modification_time() == b.expected_modification_time();
 109     case DataElement::TYPE_BLOB:
 110       return a.blob_uuid() == b.blob_uuid();
 111     case DataElement::TYPE_FILE_FILESYSTEM:
 112       return a.filesystem_url() == b.filesystem_url();
 113     case DataElement::TYPE_UNKNOWN:
 114       NOTREACHED();
 115       return false;
 116   }
 117   return false;
 118 }
 119
 120 inline bool operator!=(const DataElement& a, const DataElement& b) {
 121   return !(a == b);
 122 }
 123 #endif  // defined(UNIT_TEST)
 124
 125 }  // namespace storage
 126
 127 #endif  // STORAGE_COMMON_DATA_ELEMENT_H_