3rdparty/googletest-1.8.1/googletest/include/gtest/internal/gtest-tuple.h.pump

   1 $$ -*- mode: c++; -*-
   2 $var n = 10  $$ Maximum number of tuple fields we want to support.
   3 $$ This meta comment fixes auto-indentation in Emacs. }}
   4 // Copyright 2009 Google Inc.
   5 // All Rights Reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions are
   9 // met:
  10 //
  11 //     * Redistributions of source code must retain the above copyright
  12 // notice, this list of conditions and the following disclaimer.
  13 //     * Redistributions in binary form must reproduce the above
  14 // copyright notice, this list of conditions and the following disclaimer
  15 // in the documentation and/or other materials provided with the
  16 // distribution.
  17 //     * Neither the name of Google Inc. nor the names of its
  18 // contributors may be used to endorse or promote products derived from
  19 // this software without specific prior written permission.
  20 //
  21 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32
  33
  34 // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
  35
  36 // GOOGLETEST_CM0001 DO NOT DELETE
  37
  38 #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
  39 #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
  40
  41 #include <utility>  // For ::std::pair.
  42
  43 // The compiler used in Symbian has a bug that prevents us from declaring the
  44 // tuple template as a friend (it complains that tuple is redefined).  This
  45 // bypasses the bug by declaring the members that should otherwise be
  46 // private as public.
  47 // Sun Studio versions < 12 also have the above bug.
  48 #if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590)
  49 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
  50 #else
  51 # define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
  52     template <GTEST_$(n)_TYPENAMES_(U)> friend class tuple; \
  53    private:
  54 #endif
  55
  56 // Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict
  57 // with our own definitions. Therefore using our own tuple does not work on
  58 // those compilers.
  59 #if defined(_MSC_VER) && _MSC_VER >= 1600  /* 1600 is Visual Studio 2010 */
  60 # error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \
  61 GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers."
  62 #endif
  63
  64
  65 $range i 0..n-1
  66 $range j 0..n
  67 $range k 1..n
  68 // GTEST_n_TUPLE_(T) is the type of an n-tuple.
  69 #define GTEST_0_TUPLE_(T) tuple<>
  70
  71 $for k [[
  72 $range m 0..k-1
  73 $range m2 k..n-1
  74 #define GTEST_$(k)_TUPLE_(T) tuple<$for m, [[T##$m]]$for m2 [[, void]]>
  75
  76 ]]
  77
  78 // GTEST_n_TYPENAMES_(T) declares a list of n typenames.
  79
  80 $for j [[
  81 $range m 0..j-1
  82 #define GTEST_$(j)_TYPENAMES_(T) $for m, [[typename T##$m]]
  83
  84
  85 ]]
  86
  87 // In theory, defining stuff in the ::std namespace is undefined
  88 // behavior.  We can do this as we are playing the role of a standard
  89 // library vendor.
  90 namespace std {
  91 namespace tr1 {
  92
  93 template <$for i, [[typename T$i = void]]>
  94 class tuple;
  95
  96 // Anything in namespace gtest_internal is Google Test's INTERNAL
  97 // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
  98 namespace gtest_internal {
  99
 100 // ByRef<T>::type is T if T is a reference; otherwise it's const T&.
 101 template <typename T>
 102 struct ByRef { typedef const T& type; };  // NOLINT
 103 template <typename T>
 104 struct ByRef<T&> { typedef T& type; };  // NOLINT
 105
 106 // A handy wrapper for ByRef.
 107 #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
 108
 109 // AddRef<T>::type is T if T is a reference; otherwise it's T&.  This
 110 // is the same as tr1::add_reference<T>::type.
 111 template <typename T>
 112 struct AddRef { typedef T& type; };  // NOLINT
 113 template <typename T>
 114 struct AddRef<T&> { typedef T& type; };  // NOLINT
 115
 116 // A handy wrapper for AddRef.
 117 #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
 118
 119 // A helper for implementing get<k>().
 120 template <int k> class Get;
 121
 122 // A helper for implementing tuple_element<k, T>.  kIndexValid is true
 123 // iff k < the number of fields in tuple type T.
 124 template <bool kIndexValid, int kIndex, class Tuple>
 125 struct TupleElement;
 126
 127
 128 $for i [[
 129 template <GTEST_$(n)_TYPENAMES_(T)>
 130 struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T) > {
 131   typedef T$i type;
 132 };
 133
 134
 135 ]]
 136 }  // namespace gtest_internal
 137
 138 template <>
 139 class tuple<> {
 140  public:
 141   tuple() {}
 142   tuple(const tuple& /* t */)  {}
 143   tuple& operator=(const tuple& /* t */) { return *this; }
 144 };
 145
 146
 147 $for k [[
 148 $range m 0..k-1
 149 template <GTEST_$(k)_TYPENAMES_(T)>
 150 class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] {
 151  public:
 152   template <int k> friend class gtest_internal::Get;
 153
 154   tuple() : $for m, [[f$(m)_()]] {}
 155
 156   explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]]
 157 $for m, [[f$(m)_(f$m)]] {}
 158
 159   tuple(const tuple& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}
 160
 161   template <GTEST_$(k)_TYPENAMES_(U)>
 162   tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}
 163
 164 $if k == 2 [[
 165   template <typename U0, typename U1>
 166   tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
 167
 168 ]]
 169
 170   tuple& operator=(const tuple& t) { return CopyFrom(t); }
 171
 172   template <GTEST_$(k)_TYPENAMES_(U)>
 173   tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) {
 174     return CopyFrom(t);
 175   }
 176
 177 $if k == 2 [[
 178   template <typename U0, typename U1>
 179   tuple& operator=(const ::std::pair<U0, U1>& p) {
 180     f0_ = p.first;
 181     f1_ = p.second;
 182     return *this;
 183   }
 184
 185 ]]
 186
 187   GTEST_DECLARE_TUPLE_AS_FRIEND_
 188
 189   template <GTEST_$(k)_TYPENAMES_(U)>
 190   tuple& CopyFrom(const GTEST_$(k)_TUPLE_(U)& t) {
 191
 192 $for m [[
 193     f$(m)_ = t.f$(m)_;
 194
 195 ]]
 196     return *this;
 197   }
 198
 199
 200 $for m [[
 201   T$m f$(m)_;
 202
 203 ]]
 204 };
 205
 206
 207 ]]
 208 // 6.1.3.2 Tuple creation functions.
 209
 210 // Known limitations: we don't support passing an
 211 // std::tr1::reference_wrapper<T> to make_tuple().  And we don't
 212 // implement tie().
 213
 214 inline tuple<> make_tuple() { return tuple<>(); }
 215
 216 $for k [[
 217 $range m 0..k-1
 218
 219 template <GTEST_$(k)_TYPENAMES_(T)>
 220 inline GTEST_$(k)_TUPLE_(T) make_tuple($for m, [[const T$m& f$m]]) {
 221   return GTEST_$(k)_TUPLE_(T)($for m, [[f$m]]);
 222 }
 223
 224 ]]
 225
 226 // 6.1.3.3 Tuple helper classes.
 227
 228 template <typename Tuple> struct tuple_size;
 229
 230
 231 $for j [[
 232 template <GTEST_$(j)_TYPENAMES_(T)>
 233 struct tuple_size<GTEST_$(j)_TUPLE_(T) > {
 234   static const int value = $j;
 235 };
 236
 237
 238 ]]
 239 template <int k, class Tuple>
 240 struct tuple_element {
 241   typedef typename gtest_internal::TupleElement<
 242       k < (tuple_size<Tuple>::value), k, Tuple>::type type;
 243 };
 244
 245 #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
 246
 247 // 6.1.3.4 Element access.
 248
 249 namespace gtest_internal {
 250
 251
 252 $for i [[
 253 template <>
 254 class Get<$i> {
 255  public:
 256   template <class Tuple>
 257   static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))
 258   Field(Tuple& t) { return t.f$(i)_; }  // NOLINT
 259
 260   template <class Tuple>
 261   static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))
 262   ConstField(const Tuple& t) { return t.f$(i)_; }
 263 };
 264
 265
 266 ]]
 267 }  // namespace gtest_internal
 268
 269 template <int k, GTEST_$(n)_TYPENAMES_(T)>
 270 GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T)))
 271 get(GTEST_$(n)_TUPLE_(T)& t) {
 272   return gtest_internal::Get<k>::Field(t);
 273 }
 274
 275 template <int k, GTEST_$(n)_TYPENAMES_(T)>
 276 GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_$(n)_TUPLE_(T)))
 277 get(const GTEST_$(n)_TUPLE_(T)& t) {
 278   return gtest_internal::Get<k>::ConstField(t);
 279 }
 280
 281 // 6.1.3.5 Relational operators
 282
 283 // We only implement == and !=, as we don't have a need for the rest yet.
 284
 285 namespace gtest_internal {
 286
 287 // SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
 288 // first k fields of t1 equals the first k fields of t2.
 289 // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
 290 // k1 != k2.
 291 template <int kSize1, int kSize2>
 292 struct SameSizeTuplePrefixComparator;
 293
 294 template <>
 295 struct SameSizeTuplePrefixComparator<0, 0> {
 296   template <class Tuple1, class Tuple2>
 297   static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
 298     return true;
 299   }
 300 };
 301
 302 template <int k>
 303 struct SameSizeTuplePrefixComparator<k, k> {
 304   template <class Tuple1, class Tuple2>
 305   static bool Eq(const Tuple1& t1, const Tuple2& t2) {
 306     return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
 307         ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
 308   }
 309 };
 310
 311 }  // namespace gtest_internal
 312
 313 template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
 314 inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t,
 315                        const GTEST_$(n)_TUPLE_(U)& u) {
 316   return gtest_internal::SameSizeTuplePrefixComparator<
 317       tuple_size<GTEST_$(n)_TUPLE_(T) >::value,
 318       tuple_size<GTEST_$(n)_TUPLE_(U) >::value>::Eq(t, u);
 319 }
 320
 321 template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)>
 322 inline bool operator!=(const GTEST_$(n)_TUPLE_(T)& t,
 323                        const GTEST_$(n)_TUPLE_(U)& u) { return !(t == u); }
 324
 325 // 6.1.4 Pairs.
 326 // Unimplemented.
 327
 328 }  // namespace tr1
 329 }  // namespace std
 330
 331
 332 $for j [[
 333 #undef GTEST_$(j)_TUPLE_
 334
 335 ]]
 336
 337
 338 $for j [[
 339 #undef GTEST_$(j)_TYPENAMES_
 340
 341 ]]
 342
 343 #undef GTEST_DECLARE_TUPLE_AS_FRIEND_
 344 #undef GTEST_BY_REF_
 345 #undef GTEST_ADD_REF_
 346 #undef GTEST_TUPLE_ELEMENT_
 347
 348 #endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_