dom/quota/PersistenceScope.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 file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef DOM_QUOTA_PERSISTENCESCOPE_H_
   8 #define DOM_QUOTA_PERSISTENCESCOPE_H_
   9
  10 #include "mozilla/Assertions.h"
  11 #include "mozilla/EnumSet.h"
  12 #include "mozilla/Variant.h"
  13 #include "mozilla/dom/quota/PersistenceType.h"
  14
  15 namespace mozilla::dom::quota {
  16
  17 class PersistenceScope {
  18   class Value {
  19     PersistenceType mValue;
  20
  21    public:
  22     explicit Value(PersistenceType aValue) : mValue(aValue) {}
  23
  24     PersistenceType GetValue() const { return mValue; }
  25   };
  26
  27   class Set {
  28     EnumSet<PersistenceType> mSet;
  29
  30    public:
  31     explicit Set(const EnumSet<PersistenceType>& aSet) : mSet(aSet) {}
  32
  33     const EnumSet<PersistenceType>& GetSet() const { return mSet; }
  34   };
  35
  36   struct Null {};
  37
  38   using DataType = Variant<Value, Set, Null>;
  39
  40   DataType mData;
  41
  42  public:
  43   PersistenceScope() : mData(Null()) {}
  44
  45   // XXX Consider renaming these static methods to Create
  46   static PersistenceScope CreateFromValue(PersistenceType aValue) {
  47     return PersistenceScope(std::move(Value(aValue)));
  48   }
  49
  50   template <typename... Args>
  51   static PersistenceScope CreateFromSet(Args... aArgs) {
  52     return PersistenceScope(std::move(Set(EnumSet<PersistenceType>(aArgs...))));
  53   }
  54
  55   static PersistenceScope CreateFromNull() {
  56     return PersistenceScope(std::move(Null()));
  57   }
  58
  59   bool IsValue() const { return mData.is<Value>(); }
  60
  61   bool IsSet() const { return mData.is<Set>(); }
  62
  63   bool IsNull() const { return mData.is<Null>(); }
  64
  65   void SetFromValue(PersistenceType aValue) {
  66     mData = AsVariant(Value(aValue));
  67   }
  68
  69   void SetFromNull() { mData = AsVariant(Null()); }
  70
  71   PersistenceType GetValue() const {
  72     MOZ_ASSERT(IsValue());
  73
  74     return mData.as<Value>().GetValue();
  75   }
  76
  77   const EnumSet<PersistenceType>& GetSet() const {
  78     MOZ_ASSERT(IsSet());
  79
  80     return mData.as<Set>().GetSet();
  81   }
  82
  83   bool Matches(const PersistenceScope& aOther) const {
  84     struct Matcher {
  85       const PersistenceScope& mThis;
  86
  87       explicit Matcher(const PersistenceScope& aThis) : mThis(aThis) {}
  88
  89       bool operator()(const Value& aOther) {
  90         return mThis.MatchesValue(aOther);
  91       }
  92
  93       bool operator()(const Set& aOther) { return mThis.MatchesSet(aOther); }
  94
  95       bool operator()(const Null& aOther) { return true; }
  96     };
  97
  98     return aOther.mData.match(Matcher(*this));
  99   }
 100
 101  private:
 102   // Move constructors
 103   explicit PersistenceScope(const Value&& aValue) : mData(aValue) {}
 104
 105   explicit PersistenceScope(const Set&& aSet) : mData(aSet) {}
 106
 107   explicit PersistenceScope(const Null&& aNull) : mData(aNull) {}
 108
 109   // Copy constructor
 110   explicit PersistenceScope(const DataType& aOther) : mData(aOther) {}
 111
 112   bool MatchesValue(const Value& aOther) const {
 113     struct ValueMatcher {
 114       const Value& mOther;
 115
 116       explicit ValueMatcher(const Value& aOther) : mOther(aOther) {}
 117
 118       bool operator()(const Value& aThis) {
 119         return aThis.GetValue() == mOther.GetValue();
 120       }
 121
 122       bool operator()(const Set& aThis) {
 123         return aThis.GetSet().contains(mOther.GetValue());
 124       }
 125
 126       bool operator()(const Null& aThis) {
 127         // Null covers everything.
 128         return true;
 129       }
 130     };
 131
 132     return mData.match(ValueMatcher(aOther));
 133   }
 134
 135   bool MatchesSet(const Set& aOther) const {
 136     struct SetMatcher {
 137       const Set& mOther;
 138
 139       explicit SetMatcher(const Set& aOther) : mOther(aOther) {}
 140
 141       bool operator()(const Value& aThis) {
 142         return mOther.GetSet().contains(aThis.GetValue());
 143       }
 144
 145       bool operator()(const Set& aThis) {
 146         for (auto persistenceType : aThis.GetSet()) {
 147           if (mOther.GetSet().contains(persistenceType)) {
 148             return true;
 149           }
 150         }
 151         return false;
 152       }
 153
 154       bool operator()(const Null& aThis) {
 155         // Null covers everything.
 156         return true;
 157       }
 158     };
 159
 160     return mData.match(SetMatcher(aOther));
 161   }
 162
 163   bool operator==(const PersistenceScope& aOther) = delete;
 164 };
 165
 166 bool MatchesPersistentPersistenceScope(
 167     const PersistenceScope& aPersistenceScope);
 168
 169 bool MatchesBestEffortPersistenceScope(
 170     const PersistenceScope& aPersistenceScope);
 171
 172 }  // namespace mozilla::dom::quota
 173
 174 #endif  // DOM_QUOTA_PERSISTENCESCOPE_H_