dom/indexedDB/KeyPath.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_indexeddb_keypath_h__
   8 #define mozilla_dom_indexeddb_keypath_h__
   9
  10 #include <new>
  11 #include <utility>
  12 #include "js/TypeDecls.h"
  13 #include "mozilla/Result.h"
  14 #include "mozilla/ipc/IPCForwards.h"
  15 #include "nsISupports.h"
  16 #include "nsError.h"
  17 #include "nsString.h"
  18 #include "nsTArray.h"
  19
  20 namespace JS {
  21 template <class T>
  22 class Heap;
  23 }
  24
  25 namespace mozilla::dom {
  26
  27 class OwningStringOrStringSequence;
  28 template <typename T>
  29 class Sequence;
  30 template <typename T>
  31 struct Nullable;
  32
  33 namespace indexedDB {
  34
  35 class IndexMetadata;
  36 class Key;
  37 class ObjectStoreMetadata;
  38
  39 class KeyPath {
  40   // This private constructor is only to be used by IPDL-generated classes.
  41   friend class IndexMetadata;
  42   friend class ObjectStoreMetadata;
  43   ALLOW_DEPRECATED_READPARAM
  44
  45   KeyPath() : mType(KeyPathType::NonExistent) { MOZ_COUNT_CTOR(KeyPath); }
  46
  47  public:
  48   enum class KeyPathType { NonExistent, String, Array, EndGuard };
  49
  50   void SetType(KeyPathType aType);
  51
  52   bool AppendStringWithValidation(const nsAString& aString);
  53
  54   explicit KeyPath(int aDummy) : mType(KeyPathType::NonExistent) {
  55     MOZ_COUNT_CTOR(KeyPath);
  56   }
  57
  58   KeyPath(KeyPath&& aOther) {
  59     MOZ_COUNT_CTOR(KeyPath);
  60     *this = std::move(aOther);
  61   }
  62   KeyPath& operator=(KeyPath&&) = default;
  63
  64   KeyPath(const KeyPath& aOther) {
  65     MOZ_COUNT_CTOR(KeyPath);
  66     *this = aOther;
  67   }
  68   KeyPath& operator=(const KeyPath&) = default;
  69
  70   MOZ_COUNTED_DTOR(KeyPath)
  71
  72   static Result<KeyPath, nsresult> Parse(const nsAString& aString);
  73
  74   static Result<KeyPath, nsresult> Parse(const Sequence<nsString>& aStrings);
  75
  76   static Result<KeyPath, nsresult> Parse(
  77       const Nullable<OwningStringOrStringSequence>& aValue);
  78
  79   nsresult ExtractKey(JSContext* aCx, const JS::Value& aValue, Key& aKey) const;
  80
  81   nsresult ExtractKeyAsJSVal(JSContext* aCx, const JS::Value& aValue,
  82                              JS::Value* aOutVal) const;
  83
  84   using ExtractOrCreateKeyCallback = nsresult (*)(JSContext*, void*);
  85
  86   nsresult ExtractOrCreateKey(JSContext* aCx, const JS::Value& aValue,
  87                               Key& aKey, ExtractOrCreateKeyCallback aCallback,
  88                               void* aClosure) const;
  89
  90   inline bool IsValid() const { return mType != KeyPathType::NonExistent; }
  91
  92   inline bool IsArray() const { return mType == KeyPathType::Array; }
  93
  94   inline bool IsString() const { return mType == KeyPathType::String; }
  95
  96   inline bool IsEmpty() const {
  97     return mType == KeyPathType::String && mStrings[0].IsEmpty();
  98   }
  99
 100   bool operator==(const KeyPath& aOther) const {
 101     return mType == aOther.mType && mStrings == aOther.mStrings;
 102   }
 103
 104   nsAutoString SerializeToString() const;
 105   static KeyPath DeserializeFromString(const nsAString& aString);
 106
 107   nsresult ToJSVal(JSContext* aCx, JS::MutableHandle<JS::Value> aValue) const;
 108   nsresult ToJSVal(JSContext* aCx, JS::Heap<JS::Value>& aValue) const;
 109
 110   bool IsAllowedForObjectStore(bool aAutoIncrement) const;
 111
 112   KeyPathType mType;
 113
 114   CopyableTArray<nsString> mStrings;
 115 };
 116
 117 }  // namespace indexedDB
 118 }  // namespace mozilla::dom
 119
 120 #endif  // mozilla_dom_indexeddb_keypath_h__