mfbt/Pair.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 /* A class holding a pair of objects that tries to conserve storage space. */
   8
   9 #ifndef mozilla_Pair_h
  10 #define mozilla_Pair_h
  11
  12 #include "mozilla/Attributes.h"
  13 #include "mozilla/Move.h"
  14 #include "mozilla/TypeTraits.h"
  15
  16 namespace mozilla {
  17
  18 namespace detail {
  19
  20 enum StorageType { AsBase, AsMember };
  21
  22 // Optimize storage using the Empty Base Optimization -- that empty base classes
  23 // don't take up space -- to optimize size when one or the other class is
  24 // stateless and can be used as a base class.
  25 //
  26 // The extra conditions on storage for B are necessary so that PairHelper won't
  27 // ambiguously inherit from either A or B, such that one or the other base class
  28 // would be inaccessible.
  29 template<typename A, typename B,
  30          detail::StorageType =
  31            IsEmpty<A>::value ? detail::AsBase : detail::AsMember,
  32          detail::StorageType =
  33            IsEmpty<B>::value && !IsBaseOf<A, B>::value && !IsBaseOf<B, A>::value
  34            ? detail::AsBase
  35            : detail::AsMember>
  36 struct PairHelper;
  37
  38 template<typename A, typename B>
  39 struct PairHelper<A, B, AsMember, AsMember>
  40 {
  41 protected:
  42   template<typename AArg, typename BArg>
  43   PairHelper(AArg&& aA, BArg&& aB)
  44     : mFirstA(std::forward<AArg>(aA)),
  45       mSecondB(std::forward<BArg>(aB))
  46   {}
  47
  48   A& first() { return mFirstA; }
  49   const A& first() const { return mFirstA; }
  50   B& second() { return mSecondB; }
  51   const B& second() const { return mSecondB; }
  52
  53   void swap(PairHelper& aOther)
  54   {
  55     Swap(mFirstA, aOther.mFirstA);
  56     Swap(mSecondB, aOther.mSecondB);
  57   }
  58
  59 private:
  60   A mFirstA;
  61   B mSecondB;
  62 };
  63
  64 template<typename A, typename B>
  65 struct PairHelper<A, B, AsMember, AsBase> : private B
  66 {
  67 protected:
  68   template<typename AArg, typename BArg>
  69   PairHelper(AArg&& aA, BArg&& aB)
  70     : B(std::forward<BArg>(aB)),
  71       mFirstA(std::forward<AArg>(aA))
  72   {}
  73
  74   A& first() { return mFirstA; }
  75   const A& first() const { return mFirstA; }
  76   B& second() { return *this; }
  77   const B& second() const { return *this; }
  78
  79   void swap(PairHelper& aOther)
  80   {
  81     Swap(mFirstA, aOther.mFirstA);
  82     Swap(static_cast<B&>(*this), static_cast<B&>(aOther));
  83   }
  84
  85 private:
  86   A mFirstA;
  87 };
  88
  89 template<typename A, typename B>
  90 struct PairHelper<A, B, AsBase, AsMember> : private A
  91 {
  92 protected:
  93   template<typename AArg, typename BArg>
  94   PairHelper(AArg&& aA, BArg&& aB)
  95     : A(std::forward<AArg>(aA)),
  96       mSecondB(std::forward<BArg>(aB))
  97   {}
  98
  99   A& first() { return *this; }
 100   const A& first() const { return *this; }
 101   B& second() { return mSecondB; }
 102   const B& second() const { return mSecondB; }
 103
 104   void swap(PairHelper& aOther)
 105   {
 106     Swap(static_cast<A&>(*this), static_cast<A&>(aOther));
 107     Swap(mSecondB, aOther.mSecondB);
 108   }
 109
 110 private:
 111   B mSecondB;
 112 };
 113
 114 template<typename A, typename B>
 115 struct PairHelper<A, B, AsBase, AsBase> : private A, private B
 116 {
 117 protected:
 118   template<typename AArg, typename BArg>
 119   PairHelper(AArg&& aA, BArg&& aB)
 120     : A(std::forward<AArg>(aA)),
 121       B(std::forward<BArg>(aB))
 122   {}
 123
 124   A& first() { return static_cast<A&>(*this); }
 125   const A& first() const { return static_cast<A&>(*this); }
 126   B& second() { return static_cast<B&>(*this); }
 127   const B& second() const { return static_cast<B&>(*this); }
 128
 129   void swap(PairHelper& aOther)
 130   {
 131     Swap(static_cast<A&>(*this), static_cast<A&>(aOther));
 132     Swap(static_cast<B&>(*this), static_cast<B&>(aOther));
 133   }
 134 };
 135
 136 } // namespace detail
 137
 138 /**
 139  * Pair is the logical concatenation of an instance of A with an instance B.
 140  * Space is conserved when possible.  Neither A nor B may be a final class.
 141  *
 142  * It's typically clearer to have individual A and B member fields.  Except if
 143  * you want the space-conserving qualities of Pair, you're probably better off
 144  * not using this!
 145  *
 146  * No guarantees are provided about the memory layout of A and B, the order of
 147  * initialization or destruction of A and B, and so on.  (This is approximately
 148  * required to optimize space usage.)  The first/second names are merely
 149  * conceptual!
 150  */
 151 template<typename A, typename B>
 152 struct Pair
 153   : private detail::PairHelper<A, B>
 154 {
 155   typedef typename detail::PairHelper<A, B> Base;
 156
 157 public:
 158   template<typename AArg, typename BArg>
 159   Pair(AArg&& aA, BArg&& aB)
 160     : Base(std::forward<AArg>(aA), std::forward<BArg>(aB))
 161   {}
 162
 163   Pair(Pair&& aOther)
 164     : Base(std::move(aOther.first()), std::move(aOther.second()))
 165   { }
 166
 167   Pair(const Pair& aOther) = default;
 168
 169   Pair& operator=(Pair&& aOther)
 170   {
 171     MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
 172
 173     first() = std::move(aOther.first());
 174     second() = std::move(aOther.second());
 175
 176     return *this;
 177   }
 178
 179   Pair& operator=(const Pair& aOther) = default;
 180
 181   /** The A instance. */
 182   using Base::first;
 183   /** The B instance. */
 184   using Base::second;
 185
 186   /** Swap this pair with another pair. */
 187   void swap(Pair& aOther) { Base::swap(aOther); }
 188 };
 189
 190 template<typename A, class B>
 191 void
 192 Swap(Pair<A, B>& aX, Pair<A, B>& aY)
 193 {
 194   aX.swap(aY);
 195 }
 196
 197 /**
 198  * MakePair allows you to construct a Pair instance using type inference. A call
 199  * like this:
 200  *
 201  *   MakePair(Foo(), Bar())
 202  *
 203  * will return a Pair<Foo, Bar>.
 204  */
 205 template<typename A, typename B>
 206 Pair<typename RemoveCV<typename RemoveReference<A>::Type>::Type,
 207      typename RemoveCV<typename RemoveReference<B>::Type>::Type>
 208 MakePair(A&& aA, B&& aB)
 209 {
 210   return
 211     Pair<typename RemoveCV<typename RemoveReference<A>::Type>::Type,
 212          typename RemoveCV<typename RemoveReference<B>::Type>::Type>(
 213              std::forward<A>(aA),
 214              std::forward<B>(aB));
 215 }
 216
 217 } // namespace mozilla
 218
 219 #endif /* mozilla_Pair_h */