• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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