mfbt/EnumeratedArray.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 /* EnumeratedArray is like Array, but indexed by a typed enum. */
   8
   9 #ifndef mozilla_EnumeratedArray_h
  10 #define mozilla_EnumeratedArray_h
  11
  12 #include "mozilla/Array.h"
  13 #include "mozilla/Move.h"
  14
  15 namespace mozilla {
  16
  17 /**
  18  * EnumeratedArray is a fixed-size array container for use when an
  19  * array is indexed by a specific enum class.
  20  *
  21  * This provides type safety by guarding at compile time against accidentally
  22  * indexing such arrays with unrelated values. This also removes the need
  23  * for manual casting when using a typed enum value to index arrays.
  24  *
  25  * Aside from the typing of indices, EnumeratedArray is similar to Array.
  26  *
  27  * Example:
  28  *
  29  *   enum class AnimalSpecies {
  30  *     Cow,
  31  *     Sheep,
  32  *     Count
  33  *   };
  34  *
  35  *   EnumeratedArray<AnimalSpecies, AnimalSpecies::Count, int> headCount;
  36  *
  37  *   headCount[AnimalSpecies::Cow] = 17;
  38  *   headCount[AnimalSpecies::Sheep] = 30;
  39  *
  40  */
  41 template<typename IndexType,
  42          IndexType SizeAsEnumValue,
  43          typename ValueType>
  44 class EnumeratedArray
  45 {
  46 public:
  47   static const size_t kSize = size_t(SizeAsEnumValue);
  48
  49 private:
  50   typedef Array<ValueType, kSize> ArrayType;
  51
  52   ArrayType mArray;
  53
  54 public:
  55   EnumeratedArray() {}
  56
  57   template <typename... Args>
  58   MOZ_IMPLICIT EnumeratedArray(Args&&... aArgs)
  59     : mArray{std::forward<Args>(aArgs)...}
  60   {}
  61
  62   explicit EnumeratedArray(const EnumeratedArray& aOther)
  63   {
  64     for (size_t i = 0; i < kSize; i++) {
  65       mArray[i] = aOther.mArray[i];
  66     }
  67   }
  68
  69   EnumeratedArray(EnumeratedArray&& aOther)
  70   {
  71     for (size_t i = 0; i < kSize; i++) {
  72       mArray[i] = std::move(aOther.mArray[i]);
  73     }
  74   }
  75
  76   ValueType& operator[](IndexType aIndex)
  77   {
  78     return mArray[size_t(aIndex)];
  79   }
  80
  81   const ValueType& operator[](IndexType aIndex) const
  82   {
  83     return mArray[size_t(aIndex)];
  84   }
  85
  86   EnumeratedArray& operator =(EnumeratedArray&& aOther)
  87   {
  88     for (size_t i = 0; i < kSize; i++) {
  89       mArray[i] = std::move(aOther.mArray[i]);
  90     }
  91     return *this;
  92   }
  93
  94   typedef typename ArrayType::iterator               iterator;
  95   typedef typename ArrayType::const_iterator         const_iterator;
  96   typedef typename ArrayType::reverse_iterator       reverse_iterator;
  97   typedef typename ArrayType::const_reverse_iterator const_reverse_iterator;
  98
  99   // Methods for range-based for loops.
 100   iterator begin() { return mArray.begin(); }
 101   const_iterator begin() const { return mArray.begin(); }
 102   const_iterator cbegin() const { return mArray.cbegin(); }
 103   iterator end() { return mArray.end(); }
 104   const_iterator end() const { return mArray.end(); }
 105   const_iterator cend() const { return mArray.cend(); }
 106
 107   // Methods for reverse iterating.
 108   reverse_iterator rbegin() { return mArray.rbegin(); }
 109   const_reverse_iterator rbegin() const { return mArray.rbegin(); }
 110   const_reverse_iterator crbegin() const { return mArray.crbegin(); }
 111   reverse_iterator rend() { return mArray.rend(); }
 112   const_reverse_iterator rend() const { return mArray.rend(); }
 113   const_reverse_iterator crend() const { return mArray.crend(); }
 114 };
 115
 116 } // namespace mozilla
 117
 118 #endif // mozilla_EnumeratedArray_h