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