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