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// Author: wan@google.com (Zhanyong Wan) 34 35// Implements a subset of TR1 tuple needed by Google Test and Google Mock. 36 37#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ 38#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ 39 40#include <utility> // For ::std::pair. 41 42// The compiler used in Symbian has a bug that prevents us from declaring the 43// tuple template as a friend (it complains that tuple is redefined). This 44// hack bypasses the bug by declaring the members that should otherwise be 45// private as public. 46// Sun Studio versions < 12 also have the above bug. 47#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) 48# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: 49#else 50# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ 51 template <GTEST_$(n)_TYPENAMES_(U)> friend class tuple; \ 52 private: 53#endif 54 55// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict 56// with our own definitions. Therefore using our own tuple does not work on 57// those compilers. 58#if defined(_MSC_VER) && _MSC_VER >= 1600 /* 1600 is Visual Studio 2010 */ 59# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \ 60GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers." 61#endif 62 63 64$range i 0..n-1 65$range j 0..n 66$range k 1..n 67// GTEST_n_TUPLE_(T) is the type of an n-tuple. 68#define GTEST_0_TUPLE_(T) tuple<> 69 70$for k [[ 71$range m 0..k-1 72$range m2 k..n-1 73#define GTEST_$(k)_TUPLE_(T) tuple<$for m, [[T##$m]]$for m2 [[, void]]> 74 75]] 76 77// GTEST_n_TYPENAMES_(T) declares a list of n typenames. 78 79$for j [[ 80$range m 0..j-1 81#define GTEST_$(j)_TYPENAMES_(T) $for m, [[typename T##$m]] 82 83 84]] 85 86// In theory, defining stuff in the ::std namespace is undefined 87// behavior. We can do this as we are playing the role of a standard 88// library vendor. 89namespace std { 90namespace tr1 { 91 92template <$for i, [[typename T$i = void]]> 93class tuple; 94 95// Anything in namespace gtest_internal is Google Test's INTERNAL 96// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code. 97namespace gtest_internal { 98 99// ByRef<T>::type is T if T is a reference; otherwise it's const T&. 100template <typename T> 101struct ByRef { typedef const T& type; }; // NOLINT 102template <typename T> 103struct ByRef<T&> { typedef T& type; }; // NOLINT 104 105// A handy wrapper for ByRef. 106#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type 107 108// AddRef<T>::type is T if T is a reference; otherwise it's T&. This 109// is the same as tr1::add_reference<T>::type. 110template <typename T> 111struct AddRef { typedef T& type; }; // NOLINT 112template <typename T> 113struct AddRef<T&> { typedef T& type; }; // NOLINT 114 115// A handy wrapper for AddRef. 116#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type 117 118// A helper for implementing get<k>(). 119template <int k> class Get; 120 121// A helper for implementing tuple_element<k, T>. kIndexValid is true 122// iff k < the number of fields in tuple type T. 123template <bool kIndexValid, int kIndex, class Tuple> 124struct TupleElement; 125 126 127$for i [[ 128template <GTEST_$(n)_TYPENAMES_(T)> 129struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T) > { 130 typedef T$i type; 131}; 132 133 134]] 135} // namespace gtest_internal 136 137template <> 138class tuple<> { 139 public: 140 tuple() {} 141 tuple(const tuple& /* t */) {} 142 tuple& operator=(const tuple& /* t */) { return *this; } 143}; 144 145 146$for k [[ 147$range m 0..k-1 148template <GTEST_$(k)_TYPENAMES_(T)> 149class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] { 150 public: 151 template <int k> friend class gtest_internal::Get; 152 153 tuple() : $for m, [[f$(m)_()]] {} 154 155 explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]] 156$for m, [[f$(m)_(f$m)]] {} 157 158 tuple(const tuple& t) : $for m, [[f$(m)_(t.f$(m)_)]] {} 159 160 template <GTEST_$(k)_TYPENAMES_(U)> 161 tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {} 162 163$if k == 2 [[ 164 template <typename U0, typename U1> 165 tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {} 166 167]] 168 169 tuple& operator=(const tuple& t) { return CopyFrom(t); } 170 171 template <GTEST_$(k)_TYPENAMES_(U)> 172 tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) { 173 return CopyFrom(t); 174 } 175 176$if k == 2 [[ 177 template <typename U0, typename U1> 178 tuple& operator=(const ::std::pair<U0, U1>& p) { 179 f0_ = p.first; 180 f1_ = p.second; 181 return *this; 182 } 183 184]] 185 186 GTEST_DECLARE_TUPLE_AS_FRIEND_ 187 188 template <GTEST_$(k)_TYPENAMES_(U)> 189 tuple& CopyFrom(const GTEST_$(k)_TUPLE_(U)& t) { 190 191$for m [[ 192 f$(m)_ = t.f$(m)_; 193 194]] 195 return *this; 196 } 197 198 199$for m [[ 200 T$m f$(m)_; 201 202]] 203}; 204 205 206]] 207// 6.1.3.2 Tuple creation functions. 208 209// Known limitations: we don't support passing an 210// std::tr1::reference_wrapper<T> to make_tuple(). And we don't 211// implement tie(). 212 213inline tuple<> make_tuple() { return tuple<>(); } 214 215$for k [[ 216$range m 0..k-1 217 218template <GTEST_$(k)_TYPENAMES_(T)> 219inline GTEST_$(k)_TUPLE_(T) make_tuple($for m, [[const T$m& f$m]]) { 220 return GTEST_$(k)_TUPLE_(T)($for m, [[f$m]]); 221} 222 223]] 224 225// 6.1.3.3 Tuple helper classes. 226 227template <typename Tuple> struct tuple_size; 228 229 230$for j [[ 231template <GTEST_$(j)_TYPENAMES_(T)> 232struct tuple_size<GTEST_$(j)_TUPLE_(T) > { 233 static const int value = $j; 234}; 235 236 237]] 238template <int k, class Tuple> 239struct tuple_element { 240 typedef typename gtest_internal::TupleElement< 241 k < (tuple_size<Tuple>::value), k, Tuple>::type type; 242}; 243 244#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type 245 246// 6.1.3.4 Element access. 247 248namespace gtest_internal { 249 250 251$for i [[ 252template <> 253class Get<$i> { 254 public: 255 template <class Tuple> 256 static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple)) 257 Field(Tuple& t) { return t.f$(i)_; } // NOLINT 258 259 template <class Tuple> 260 static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple)) 261 ConstField(const Tuple& t) { return t.f$(i)_; } 262}; 263 264 265]] 266} // namespace gtest_internal 267 268template <int k, GTEST_$(n)_TYPENAMES_(T)> 269GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T))) 270get(GTEST_$(n)_TUPLE_(T)& t) { 271 return gtest_internal::Get<k>::Field(t); 272} 273 274template <int k, GTEST_$(n)_TYPENAMES_(T)> 275GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T))) 276get(const GTEST_$(n)_TUPLE_(T)& t) { 277 return gtest_internal::Get<k>::ConstField(t); 278} 279 280// 6.1.3.5 Relational operators 281 282// We only implement == and !=, as we don't have a need for the rest yet. 283 284namespace gtest_internal { 285 286// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the 287// first k fields of t1 equals the first k fields of t2. 288// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if 289// k1 != k2. 290template <int kSize1, int kSize2> 291struct SameSizeTuplePrefixComparator; 292 293template <> 294struct SameSizeTuplePrefixComparator<0, 0> { 295 template <class Tuple1, class Tuple2> 296 static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { 297 return true; 298 } 299}; 300 301template <int k> 302struct SameSizeTuplePrefixComparator<k, k> { 303 template <class Tuple1, class Tuple2> 304 static bool Eq(const Tuple1& t1, const Tuple2& t2) { 305 return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) && 306 ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2); 307 } 308}; 309 310} // namespace gtest_internal 311 312template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)> 313inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t, 314 const GTEST_$(n)_TUPLE_(U)& u) { 315 return gtest_internal::SameSizeTuplePrefixComparator< 316 tuple_size<GTEST_$(n)_TUPLE_(T) >::value, 317 tuple_size<GTEST_$(n)_TUPLE_(U) >::value>::Eq(t, u); 318} 319 320template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)> 321inline bool operator!=(const GTEST_$(n)_TUPLE_(T)& t, 322 const GTEST_$(n)_TUPLE_(U)& u) { return !(t == u); } 323 324// 6.1.4 Pairs. 325// Unimplemented. 326 327} // namespace tr1 328} // namespace std 329 330 331$for j [[ 332#undef GTEST_$(j)_TUPLE_ 333 334]] 335 336 337$for j [[ 338#undef GTEST_$(j)_TYPENAMES_ 339 340]] 341 342#undef GTEST_DECLARE_TUPLE_AS_FRIEND_ 343#undef GTEST_BY_REF_ 344#undef GTEST_ADD_REF_ 345#undef GTEST_TUPLE_ELEMENT_ 346 347#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ 348