accessible/base/AccAttributes.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef AccAttributes_h_
   7 #define AccAttributes_h_
   8
   9 #include "mozilla/ServoStyleConsts.h"
  10 #include "mozilla/a11y/AccGroupInfo.h"
  11 #include "mozilla/Variant.h"
  12 #include "nsTHashMap.h"
  13 #include "nsAtom.h"
  14 #include "nsStringFwd.h"
  15 #include "mozilla/gfx/Matrix.h"
  16
  17 class nsVariant;
  18
  19 namespace IPC {
  20 template <typename T>
  21 struct ParamTraits;
  22 }  // namespace IPC
  23
  24 namespace mozilla {
  25
  26 namespace dom {
  27 class Element;
  28 }
  29
  30 namespace a11y {
  31
  32 struct FontSize {
  33   int32_t mValue;
  34
  35   bool operator==(const FontSize& aOther) const {
  36     return mValue == aOther.mValue;
  37   }
  38
  39   bool operator!=(const FontSize& aOther) const {
  40     return mValue != aOther.mValue;
  41   }
  42 };
  43
  44 struct Color {
  45   nscolor mValue;
  46
  47   bool operator==(const Color& aOther) const { return mValue == aOther.mValue; }
  48
  49   bool operator!=(const Color& aOther) const { return mValue != aOther.mValue; }
  50 };
  51
  52 // A special type. If an entry has a value of this type, it instructs the
  53 // target instance of an Update to remove the entry with the same key value.
  54 struct DeleteEntry {
  55   DeleteEntry() : mValue(true) {}
  56   bool mValue;
  57
  58   bool operator==(const DeleteEntry& aOther) const { return true; }
  59
  60   bool operator!=(const DeleteEntry& aOther) const { return false; }
  61 };
  62
  63 class AccAttributes {
  64   // Warning! An AccAttributes can contain another AccAttributes. This is
  65   // intended for object and text attributes. However, the nested
  66   // AccAttributes should never itself contain another AccAttributes, nor
  67   // should it create a cycle. We don't do cycle collection here for
  68   // performance reasons, so violating this rule will cause leaks!
  69   using AttrValueType =
  70       Variant<bool, float, double, int32_t, RefPtr<nsAtom>, nsTArray<int32_t>,
  71               CSSCoord, FontSize, Color, DeleteEntry, UniquePtr<nsString>,
  72               RefPtr<AccAttributes>, uint64_t, UniquePtr<AccGroupInfo>,
  73               UniquePtr<gfx::Matrix4x4>, nsTArray<uint64_t>>;
  74   static_assert(sizeof(AttrValueType) <= 16);
  75   using AtomVariantMap = nsTHashMap<nsRefPtrHashKey<nsAtom>, AttrValueType>;
  76
  77  protected:
  78   ~AccAttributes() = default;
  79
  80  public:
  81   AccAttributes() = default;
  82   AccAttributes(AccAttributes&&) = delete;
  83   AccAttributes& operator=(AccAttributes&&) = delete;
  84   AccAttributes(const AccAttributes&) = delete;
  85   AccAttributes& operator=(const AccAttributes&) = delete;
  86
  87   NS_INLINE_DECL_REFCOUNTING(mozilla::a11y::AccAttributes)
  88
  89   template <typename T, typename std::enable_if<
  90                             !std::is_convertible_v<T, nsString> &&
  91                                 !std::is_convertible_v<T, AccGroupInfo*> &&
  92                                 !std::is_convertible_v<T, gfx::Matrix4x4> &&
  93                                 !std::is_convertible_v<T, nsAtom*>,
  94                             bool>::type = true>
  95   void SetAttribute(nsAtom* aAttrName, T&& aAttrValue) {
  96     mData.InsertOrUpdate(aAttrName, AsVariant(std::forward<T>(aAttrValue)));
  97   }
  98
  99   void SetAttribute(nsAtom* aAttrName, nsString&& aAttrValue) {
 100     UniquePtr<nsString> value = MakeUnique<nsString>();
 101     *value = std::forward<nsString>(aAttrValue);
 102     mData.InsertOrUpdate(aAttrName, AsVariant(std::move(value)));
 103   }
 104
 105   void SetAttribute(nsAtom* aAttrName, AccGroupInfo* aAttrValue) {
 106     UniquePtr<AccGroupInfo> value(aAttrValue);
 107     mData.InsertOrUpdate(aAttrName, AsVariant(std::move(value)));
 108   }
 109
 110   void SetAttribute(nsAtom* aAttrName, gfx::Matrix4x4&& aAttrValue) {
 111     UniquePtr<gfx::Matrix4x4> value = MakeUnique<gfx::Matrix4x4>();
 112     *value = std::forward<gfx::Matrix4x4>(aAttrValue);
 113     mData.InsertOrUpdate(aAttrName, AsVariant(std::move(value)));
 114   }
 115
 116   void SetAttributeStringCopy(nsAtom* aAttrName, nsString aAttrValue) {
 117     SetAttribute(aAttrName, std::move(aAttrValue));
 118   }
 119
 120   void SetAttribute(nsAtom* aAttrName, nsAtom* aAttrValue) {
 121     mData.InsertOrUpdate(aAttrName, AsVariant(RefPtr<nsAtom>(aAttrValue)));
 122   }
 123
 124   template <typename T>
 125   Maybe<const T&> GetAttribute(nsAtom* aAttrName) {
 126     if (auto value = mData.Lookup(aAttrName)) {
 127       if constexpr (std::is_same_v<nsString, T>) {
 128         if (value->is<UniquePtr<nsString>>()) {
 129           const T& val = *(value->as<UniquePtr<nsString>>().get());
 130           return SomeRef(val);
 131         }
 132       } else if constexpr (std::is_same_v<gfx::Matrix4x4, T>) {
 133         if (value->is<UniquePtr<gfx::Matrix4x4>>()) {
 134           const T& val = *(value->as<UniquePtr<gfx::Matrix4x4>>());
 135           return SomeRef(val);
 136         }
 137       } else {
 138         if (value->is<T>()) {
 139           const T& val = value->as<T>();
 140           return SomeRef(val);
 141         }
 142       }
 143     }
 144     return Nothing();
 145   }
 146
 147   template <typename T>
 148   RefPtr<const T> GetAttributeRefPtr(nsAtom* aAttrName) {
 149     if (auto value = mData.Lookup(aAttrName)) {
 150       if (value->is<RefPtr<T>>()) {
 151         RefPtr<const T> ref = value->as<RefPtr<T>>();
 152         return ref;
 153       }
 154     }
 155     return nullptr;
 156   }
 157
 158   // Get stringified value
 159   bool GetAttribute(nsAtom* aAttrName, nsAString& aAttrValue);
 160
 161   bool HasAttribute(nsAtom* aAttrName) { return mData.Contains(aAttrName); }
 162
 163   bool Remove(nsAtom* aAttrName) { return mData.Remove(aAttrName); }
 164
 165   uint32_t Count() const { return mData.Count(); }
 166
 167   // Update one instance with the entries in another. The supplied AccAttributes
 168   // will be emptied.
 169   void Update(AccAttributes* aOther);
 170
 171   /**
 172    * Return true if all the attributes in this instance are equal to all the
 173    * attributes in another instance.
 174    */
 175   bool Equal(const AccAttributes* aOther) const;
 176
 177   /**
 178    * Copy attributes from this instance to another instance.
 179    * This should only be used in very specific cases; e.g. merging two sets of
 180    * cached attributes without modifying the cache. It can only copy simple
 181    * value types; e.g. it can't copy array values. Attempting to copy an
 182    * AccAttributes with uncopyable values will cause an assertion.
 183    */
 184   void CopyTo(AccAttributes* aDest) const;
 185
 186   // An entry class for our iterator.
 187   class Entry {
 188    public:
 189     Entry(nsAtom* aAttrName, const AttrValueType* aAttrValue)
 190         : mName(aAttrName), mValue(aAttrValue) {}
 191
 192     nsAtom* Name() { return mName; }
 193
 194     template <typename T>
 195     Maybe<const T&> Value() {
 196       if constexpr (std::is_same_v<nsString, T>) {
 197         if (mValue->is<UniquePtr<nsString>>()) {
 198           const T& val = *(mValue->as<UniquePtr<nsString>>().get());
 199           return SomeRef(val);
 200         }
 201       } else if constexpr (std::is_same_v<gfx::Matrix4x4, T>) {
 202         if (mValue->is<UniquePtr<gfx::Matrix4x4>>()) {
 203           const T& val = *(mValue->as<UniquePtr<gfx::Matrix4x4>>());
 204           return SomeRef(val);
 205         }
 206       } else {
 207         if (mValue->is<T>()) {
 208           const T& val = mValue->as<T>();
 209           return SomeRef(val);
 210         }
 211       }
 212       return Nothing();
 213     }
 214
 215     void NameAsString(nsString& aName) {
 216       mName->ToString(aName);
 217       if (aName.Find("aria-", false, 0, 1) == 0) {
 218         // Found 'aria-'
 219         aName.ReplaceLiteral(0, 5, u"");
 220       }
 221     }
 222
 223     void ValueAsString(nsAString& aValueString) {
 224       StringFromValueAndName(mName, *mValue, aValueString);
 225     }
 226
 227    private:
 228     nsAtom* mName;
 229     const AttrValueType* mValue;
 230
 231     friend class AccAttributes;
 232   };
 233
 234   class Iterator {
 235    public:
 236     explicit Iterator(AtomVariantMap::iterator aIter) : mHashIterator(aIter) {}
 237
 238     Iterator() = delete;
 239     Iterator(const Iterator&) = delete;
 240     Iterator(Iterator&&) = delete;
 241     Iterator& operator=(const Iterator&) = delete;
 242     Iterator& operator=(Iterator&&) = delete;
 243
 244     bool operator!=(const Iterator& aOther) const {
 245       return mHashIterator != aOther.mHashIterator;
 246     }
 247
 248     Iterator& operator++() {
 249       mHashIterator++;
 250       return *this;
 251     }
 252
 253     Entry operator*() {
 254       auto& entry = *mHashIterator;
 255       return Entry(entry.GetKey(), &entry.GetData());
 256     }
 257
 258    private:
 259     AtomVariantMap::iterator mHashIterator;
 260   };
 261
 262   friend class Iterator;
 263
 264   Iterator begin() { return Iterator(mData.begin()); }
 265   Iterator end() { return Iterator(mData.end()); }
 266
 267  private:
 268   static void StringFromValueAndName(nsAtom* aAttrName,
 269                                      const AttrValueType& aValue,
 270                                      nsAString& aValueString);
 271
 272   AtomVariantMap mData;
 273
 274   friend struct IPC::ParamTraits<AccAttributes*>;
 275 };
 276
 277 }  // namespace a11y
 278 }  // namespace mozilla
 279
 280 #endif