Differential D18622 Diff 52199 google/googletest/dist/googletest/include/gtest/internal/gtest-tuple.h
Changeset View
Changeset View
Standalone View
Standalone View
google/googletest/dist/googletest/include/gtest/internal/gtest-tuple.h
- This file was added.
Property | Old Value | New Value |
---|---|---|
svn:eol-style | null | native \ No newline at end of property |
svn:keywords | null | FreeBSD=%H \ No newline at end of property |
svn:mime-type | null | text/plain \ No newline at end of property |
// This file was GENERATED by command: | |||||
// pump.py gtest-tuple.h.pump | |||||
// DO NOT EDIT BY HAND!!! | |||||
// Copyright 2009 Google Inc. | |||||
// All Rights Reserved. | |||||
// | |||||
// Redistribution and use in source and binary forms, with or without | |||||
// modification, are permitted provided that the following conditions are | |||||
// met: | |||||
// | |||||
// * Redistributions of source code must retain the above copyright | |||||
// notice, this list of conditions and the following disclaimer. | |||||
// * Redistributions in binary form must reproduce the above | |||||
// copyright notice, this list of conditions and the following disclaimer | |||||
// in the documentation and/or other materials provided with the | |||||
// distribution. | |||||
// * Neither the name of Google Inc. nor the names of its | |||||
// contributors may be used to endorse or promote products derived from | |||||
// this software without specific prior written permission. | |||||
// | |||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |||||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |||||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |||||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |||||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |||||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |||||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |||||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |||||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |||||
// Implements a subset of TR1 tuple needed by Google Test and Google Mock. | |||||
// GOOGLETEST_CM0001 DO NOT DELETE | |||||
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ | |||||
#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ | |||||
#include <utility> // For ::std::pair. | |||||
// The compiler used in Symbian has a bug that prevents us from declaring the | |||||
// tuple template as a friend (it complains that tuple is redefined). This | |||||
// bypasses the bug by declaring the members that should otherwise be | |||||
// private as public. | |||||
// Sun Studio versions < 12 also have the above bug. | |||||
#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) | |||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: | |||||
#else | |||||
# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ | |||||
template <GTEST_10_TYPENAMES_(U)> friend class tuple; \ | |||||
private: | |||||
#endif | |||||
// Visual Studio 2010, 2012, and 2013 define symbols in std::tr1 that conflict | |||||
// with our own definitions. Therefore using our own tuple does not work on | |||||
// those compilers. | |||||
#if defined(_MSC_VER) && _MSC_VER >= 1600 /* 1600 is Visual Studio 2010 */ | |||||
# error "gtest's tuple doesn't compile on Visual Studio 2010 or later. \ | |||||
GTEST_USE_OWN_TR1_TUPLE must be set to 0 on those compilers." | |||||
#endif | |||||
// GTEST_n_TUPLE_(T) is the type of an n-tuple. | |||||
#define GTEST_0_TUPLE_(T) tuple<> | |||||
#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \ | |||||
void, void, void> | |||||
#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \ | |||||
void, void, void> | |||||
#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \ | |||||
void, void, void> | |||||
#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \ | |||||
void, void, void> | |||||
#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \ | |||||
void, void, void> | |||||
#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \ | |||||
void, void, void> | |||||
#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ | |||||
void, void, void> | |||||
#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ | |||||
T##7, void, void> | |||||
#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ | |||||
T##7, T##8, void> | |||||
#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ | |||||
T##7, T##8, T##9> | |||||
// GTEST_n_TYPENAMES_(T) declares a list of n typenames. | |||||
#define GTEST_0_TYPENAMES_(T) | |||||
#define GTEST_1_TYPENAMES_(T) typename T##0 | |||||
#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1 | |||||
#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2 | |||||
#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ | |||||
typename T##3 | |||||
#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ | |||||
typename T##3, typename T##4 | |||||
#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ | |||||
typename T##3, typename T##4, typename T##5 | |||||
#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ | |||||
typename T##3, typename T##4, typename T##5, typename T##6 | |||||
#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ | |||||
typename T##3, typename T##4, typename T##5, typename T##6, typename T##7 | |||||
#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ | |||||
typename T##3, typename T##4, typename T##5, typename T##6, \ | |||||
typename T##7, typename T##8 | |||||
#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ | |||||
typename T##3, typename T##4, typename T##5, typename T##6, \ | |||||
typename T##7, typename T##8, typename T##9 | |||||
// In theory, defining stuff in the ::std namespace is undefined | |||||
// behavior. We can do this as we are playing the role of a standard | |||||
// library vendor. | |||||
namespace std { | |||||
namespace tr1 { | |||||
template <typename T0 = void, typename T1 = void, typename T2 = void, | |||||
typename T3 = void, typename T4 = void, typename T5 = void, | |||||
typename T6 = void, typename T7 = void, typename T8 = void, | |||||
typename T9 = void> | |||||
class tuple; | |||||
// Anything in namespace gtest_internal is Google Test's INTERNAL | |||||
// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code. | |||||
namespace gtest_internal { | |||||
// ByRef<T>::type is T if T is a reference; otherwise it's const T&. | |||||
template <typename T> | |||||
struct ByRef { typedef const T& type; }; // NOLINT | |||||
template <typename T> | |||||
struct ByRef<T&> { typedef T& type; }; // NOLINT | |||||
// A handy wrapper for ByRef. | |||||
#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type | |||||
// AddRef<T>::type is T if T is a reference; otherwise it's T&. This | |||||
// is the same as tr1::add_reference<T>::type. | |||||
template <typename T> | |||||
struct AddRef { typedef T& type; }; // NOLINT | |||||
template <typename T> | |||||
struct AddRef<T&> { typedef T& type; }; // NOLINT | |||||
// A handy wrapper for AddRef. | |||||
#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type | |||||
// A helper for implementing get<k>(). | |||||
template <int k> class Get; | |||||
// A helper for implementing tuple_element<k, T>. kIndexValid is true | |||||
// iff k < the number of fields in tuple type T. | |||||
template <bool kIndexValid, int kIndex, class Tuple> | |||||
struct TupleElement; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 0, GTEST_10_TUPLE_(T) > { | |||||
typedef T0 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 1, GTEST_10_TUPLE_(T) > { | |||||
typedef T1 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 2, GTEST_10_TUPLE_(T) > { | |||||
typedef T2 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 3, GTEST_10_TUPLE_(T) > { | |||||
typedef T3 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 4, GTEST_10_TUPLE_(T) > { | |||||
typedef T4 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 5, GTEST_10_TUPLE_(T) > { | |||||
typedef T5 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 6, GTEST_10_TUPLE_(T) > { | |||||
typedef T6 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 7, GTEST_10_TUPLE_(T) > { | |||||
typedef T7 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 8, GTEST_10_TUPLE_(T) > { | |||||
typedef T8 type; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct TupleElement<true, 9, GTEST_10_TUPLE_(T) > { | |||||
typedef T9 type; | |||||
}; | |||||
} // namespace gtest_internal | |||||
template <> | |||||
class tuple<> { | |||||
public: | |||||
tuple() {} | |||||
tuple(const tuple& /* t */) {} | |||||
tuple& operator=(const tuple& /* t */) { return *this; } | |||||
}; | |||||
template <GTEST_1_TYPENAMES_(T)> | |||||
class GTEST_1_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {} | |||||
tuple(const tuple& t) : f0_(t.f0_) {} | |||||
template <GTEST_1_TYPENAMES_(U)> | |||||
tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_1_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_1_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_1_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
}; | |||||
template <GTEST_2_TYPENAMES_(T)> | |||||
class GTEST_2_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0), | |||||
f1_(f1) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {} | |||||
template <GTEST_2_TYPENAMES_(U)> | |||||
tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {} | |||||
template <typename U0, typename U1> | |||||
tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_2_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_2_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
template <typename U0, typename U1> | |||||
tuple& operator=(const ::std::pair<U0, U1>& p) { | |||||
f0_ = p.first; | |||||
f1_ = p.second; | |||||
return *this; | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_2_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
}; | |||||
template <GTEST_3_TYPENAMES_(T)> | |||||
class GTEST_3_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_(), f2_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, | |||||
GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} | |||||
template <GTEST_3_TYPENAMES_(U)> | |||||
tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_3_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_3_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_3_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
f2_ = t.f2_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
T2 f2_; | |||||
}; | |||||
template <GTEST_4_TYPENAMES_(T)> | |||||
class GTEST_4_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_(), f2_(), f3_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, | |||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2), | |||||
f3_(f3) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {} | |||||
template <GTEST_4_TYPENAMES_(U)> | |||||
tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), | |||||
f3_(t.f3_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_4_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_4_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_4_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
f2_ = t.f2_; | |||||
f3_ = t.f3_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
T2 f2_; | |||||
T3 f3_; | |||||
}; | |||||
template <GTEST_5_TYPENAMES_(T)> | |||||
class GTEST_5_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, | |||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, | |||||
GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), | |||||
f4_(t.f4_) {} | |||||
template <GTEST_5_TYPENAMES_(U)> | |||||
tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), | |||||
f3_(t.f3_), f4_(t.f4_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_5_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_5_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_5_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
f2_ = t.f2_; | |||||
f3_ = t.f3_; | |||||
f4_ = t.f4_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
T2 f2_; | |||||
T3 f3_; | |||||
T4 f4_; | |||||
}; | |||||
template <GTEST_6_TYPENAMES_(T)> | |||||
class GTEST_6_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, | |||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, | |||||
GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), | |||||
f5_(f5) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), | |||||
f4_(t.f4_), f5_(t.f5_) {} | |||||
template <GTEST_6_TYPENAMES_(U)> | |||||
tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), | |||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_6_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_6_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_6_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
f2_ = t.f2_; | |||||
f3_ = t.f3_; | |||||
f4_ = t.f4_; | |||||
f5_ = t.f5_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
T2 f2_; | |||||
T3 f3_; | |||||
T4 f4_; | |||||
T5 f5_; | |||||
}; | |||||
template <GTEST_7_TYPENAMES_(T)> | |||||
class GTEST_7_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, | |||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, | |||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2), | |||||
f3_(f3), f4_(f4), f5_(f5), f6_(f6) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), | |||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} | |||||
template <GTEST_7_TYPENAMES_(U)> | |||||
tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), | |||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_7_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_7_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_7_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
f2_ = t.f2_; | |||||
f3_ = t.f3_; | |||||
f4_ = t.f4_; | |||||
f5_ = t.f5_; | |||||
f6_ = t.f6_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
T2 f2_; | |||||
T3 f3_; | |||||
T4 f4_; | |||||
T5 f5_; | |||||
T6 f6_; | |||||
}; | |||||
template <GTEST_8_TYPENAMES_(T)> | |||||
class GTEST_8_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, | |||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, | |||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, | |||||
GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), | |||||
f5_(f5), f6_(f6), f7_(f7) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), | |||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} | |||||
template <GTEST_8_TYPENAMES_(U)> | |||||
tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), | |||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_8_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_8_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_8_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
f2_ = t.f2_; | |||||
f3_ = t.f3_; | |||||
f4_ = t.f4_; | |||||
f5_ = t.f5_; | |||||
f6_ = t.f6_; | |||||
f7_ = t.f7_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
T2 f2_; | |||||
T3 f3_; | |||||
T4 f4_; | |||||
T5 f5_; | |||||
T6 f6_; | |||||
T7 f7_; | |||||
}; | |||||
template <GTEST_9_TYPENAMES_(T)> | |||||
class GTEST_9_TUPLE_(T) { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, | |||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, | |||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, | |||||
GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), | |||||
f5_(f5), f6_(f6), f7_(f7), f8_(f8) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), | |||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} | |||||
template <GTEST_9_TYPENAMES_(U)> | |||||
tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), | |||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_9_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_9_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_9_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
f2_ = t.f2_; | |||||
f3_ = t.f3_; | |||||
f4_ = t.f4_; | |||||
f5_ = t.f5_; | |||||
f6_ = t.f6_; | |||||
f7_ = t.f7_; | |||||
f8_ = t.f8_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
T2 f2_; | |||||
T3 f3_; | |||||
T4 f4_; | |||||
T5 f5_; | |||||
T6 f6_; | |||||
T7 f7_; | |||||
T8 f8_; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
class tuple { | |||||
public: | |||||
template <int k> friend class gtest_internal::Get; | |||||
tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(), | |||||
f9_() {} | |||||
explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, | |||||
GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, | |||||
GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, | |||||
GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2), | |||||
f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {} | |||||
tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), | |||||
f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {} | |||||
template <GTEST_10_TYPENAMES_(U)> | |||||
tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), | |||||
f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), | |||||
f9_(t.f9_) {} | |||||
tuple& operator=(const tuple& t) { return CopyFrom(t); } | |||||
template <GTEST_10_TYPENAMES_(U)> | |||||
tuple& operator=(const GTEST_10_TUPLE_(U)& t) { | |||||
return CopyFrom(t); | |||||
} | |||||
GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
template <GTEST_10_TYPENAMES_(U)> | |||||
tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) { | |||||
f0_ = t.f0_; | |||||
f1_ = t.f1_; | |||||
f2_ = t.f2_; | |||||
f3_ = t.f3_; | |||||
f4_ = t.f4_; | |||||
f5_ = t.f5_; | |||||
f6_ = t.f6_; | |||||
f7_ = t.f7_; | |||||
f8_ = t.f8_; | |||||
f9_ = t.f9_; | |||||
return *this; | |||||
} | |||||
T0 f0_; | |||||
T1 f1_; | |||||
T2 f2_; | |||||
T3 f3_; | |||||
T4 f4_; | |||||
T5 f5_; | |||||
T6 f6_; | |||||
T7 f7_; | |||||
T8 f8_; | |||||
T9 f9_; | |||||
}; | |||||
// 6.1.3.2 Tuple creation functions. | |||||
// Known limitations: we don't support passing an | |||||
// std::tr1::reference_wrapper<T> to make_tuple(). And we don't | |||||
// implement tie(). | |||||
inline tuple<> make_tuple() { return tuple<>(); } | |||||
template <GTEST_1_TYPENAMES_(T)> | |||||
inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { | |||||
return GTEST_1_TUPLE_(T)(f0); | |||||
} | |||||
template <GTEST_2_TYPENAMES_(T)> | |||||
inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { | |||||
return GTEST_2_TUPLE_(T)(f0, f1); | |||||
} | |||||
template <GTEST_3_TYPENAMES_(T)> | |||||
inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) { | |||||
return GTEST_3_TUPLE_(T)(f0, f1, f2); | |||||
} | |||||
template <GTEST_4_TYPENAMES_(T)> | |||||
inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, | |||||
const T3& f3) { | |||||
return GTEST_4_TUPLE_(T)(f0, f1, f2, f3); | |||||
} | |||||
template <GTEST_5_TYPENAMES_(T)> | |||||
inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, | |||||
const T3& f3, const T4& f4) { | |||||
return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4); | |||||
} | |||||
template <GTEST_6_TYPENAMES_(T)> | |||||
inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, | |||||
const T3& f3, const T4& f4, const T5& f5) { | |||||
return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5); | |||||
} | |||||
template <GTEST_7_TYPENAMES_(T)> | |||||
inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, | |||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6) { | |||||
return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6); | |||||
} | |||||
template <GTEST_8_TYPENAMES_(T)> | |||||
inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, | |||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) { | |||||
return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7); | |||||
} | |||||
template <GTEST_9_TYPENAMES_(T)> | |||||
inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, | |||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, | |||||
const T8& f8) { | |||||
return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8); | |||||
} | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, | |||||
const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, | |||||
const T8& f8, const T9& f9) { | |||||
return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9); | |||||
} | |||||
// 6.1.3.3 Tuple helper classes. | |||||
template <typename Tuple> struct tuple_size; | |||||
template <GTEST_0_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_0_TUPLE_(T) > { | |||||
static const int value = 0; | |||||
}; | |||||
template <GTEST_1_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_1_TUPLE_(T) > { | |||||
static const int value = 1; | |||||
}; | |||||
template <GTEST_2_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_2_TUPLE_(T) > { | |||||
static const int value = 2; | |||||
}; | |||||
template <GTEST_3_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_3_TUPLE_(T) > { | |||||
static const int value = 3; | |||||
}; | |||||
template <GTEST_4_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_4_TUPLE_(T) > { | |||||
static const int value = 4; | |||||
}; | |||||
template <GTEST_5_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_5_TUPLE_(T) > { | |||||
static const int value = 5; | |||||
}; | |||||
template <GTEST_6_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_6_TUPLE_(T) > { | |||||
static const int value = 6; | |||||
}; | |||||
template <GTEST_7_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_7_TUPLE_(T) > { | |||||
static const int value = 7; | |||||
}; | |||||
template <GTEST_8_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_8_TUPLE_(T) > { | |||||
static const int value = 8; | |||||
}; | |||||
template <GTEST_9_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_9_TUPLE_(T) > { | |||||
static const int value = 9; | |||||
}; | |||||
template <GTEST_10_TYPENAMES_(T)> | |||||
struct tuple_size<GTEST_10_TUPLE_(T) > { | |||||
static const int value = 10; | |||||
}; | |||||
template <int k, class Tuple> | |||||
struct tuple_element { | |||||
typedef typename gtest_internal::TupleElement< | |||||
k < (tuple_size<Tuple>::value), k, Tuple>::type type; | |||||
}; | |||||
#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type | |||||
// 6.1.3.4 Element access. | |||||
namespace gtest_internal { | |||||
template <> | |||||
class Get<0> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) | |||||
Field(Tuple& t) { return t.f0_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f0_; } | |||||
}; | |||||
template <> | |||||
class Get<1> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) | |||||
Field(Tuple& t) { return t.f1_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f1_; } | |||||
}; | |||||
template <> | |||||
class Get<2> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) | |||||
Field(Tuple& t) { return t.f2_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f2_; } | |||||
}; | |||||
template <> | |||||
class Get<3> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) | |||||
Field(Tuple& t) { return t.f3_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f3_; } | |||||
}; | |||||
template <> | |||||
class Get<4> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) | |||||
Field(Tuple& t) { return t.f4_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f4_; } | |||||
}; | |||||
template <> | |||||
class Get<5> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) | |||||
Field(Tuple& t) { return t.f5_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f5_; } | |||||
}; | |||||
template <> | |||||
class Get<6> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) | |||||
Field(Tuple& t) { return t.f6_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f6_; } | |||||
}; | |||||
template <> | |||||
class Get<7> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) | |||||
Field(Tuple& t) { return t.f7_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f7_; } | |||||
}; | |||||
template <> | |||||
class Get<8> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) | |||||
Field(Tuple& t) { return t.f8_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f8_; } | |||||
}; | |||||
template <> | |||||
class Get<9> { | |||||
public: | |||||
template <class Tuple> | |||||
static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) | |||||
Field(Tuple& t) { return t.f9_; } // NOLINT | |||||
template <class Tuple> | |||||
static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) | |||||
ConstField(const Tuple& t) { return t.f9_; } | |||||
}; | |||||
} // namespace gtest_internal | |||||
template <int k, GTEST_10_TYPENAMES_(T)> | |||||
GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) | |||||
get(GTEST_10_TUPLE_(T)& t) { | |||||
return gtest_internal::Get<k>::Field(t); | |||||
} | |||||
template <int k, GTEST_10_TYPENAMES_(T)> | |||||
GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) | |||||
get(const GTEST_10_TUPLE_(T)& t) { | |||||
return gtest_internal::Get<k>::ConstField(t); | |||||
} | |||||
// 6.1.3.5 Relational operators | |||||
// We only implement == and !=, as we don't have a need for the rest yet. | |||||
namespace gtest_internal { | |||||
// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the | |||||
// first k fields of t1 equals the first k fields of t2. | |||||
// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if | |||||
// k1 != k2. | |||||
template <int kSize1, int kSize2> | |||||
struct SameSizeTuplePrefixComparator; | |||||
template <> | |||||
struct SameSizeTuplePrefixComparator<0, 0> { | |||||
template <class Tuple1, class Tuple2> | |||||
static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { | |||||
return true; | |||||
} | |||||
}; | |||||
template <int k> | |||||
struct SameSizeTuplePrefixComparator<k, k> { | |||||
template <class Tuple1, class Tuple2> | |||||
static bool Eq(const Tuple1& t1, const Tuple2& t2) { | |||||
return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) && | |||||
::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2); | |||||
} | |||||
}; | |||||
} // namespace gtest_internal | |||||
template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> | |||||
inline bool operator==(const GTEST_10_TUPLE_(T)& t, | |||||
const GTEST_10_TUPLE_(U)& u) { | |||||
return gtest_internal::SameSizeTuplePrefixComparator< | |||||
tuple_size<GTEST_10_TUPLE_(T) >::value, | |||||
tuple_size<GTEST_10_TUPLE_(U) >::value>::Eq(t, u); | |||||
} | |||||
template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> | |||||
inline bool operator!=(const GTEST_10_TUPLE_(T)& t, | |||||
const GTEST_10_TUPLE_(U)& u) { return !(t == u); } | |||||
// 6.1.4 Pairs. | |||||
// Unimplemented. | |||||
} // namespace tr1 | |||||
} // namespace std | |||||
#undef GTEST_0_TUPLE_ | |||||
#undef GTEST_1_TUPLE_ | |||||
#undef GTEST_2_TUPLE_ | |||||
#undef GTEST_3_TUPLE_ | |||||
#undef GTEST_4_TUPLE_ | |||||
#undef GTEST_5_TUPLE_ | |||||
#undef GTEST_6_TUPLE_ | |||||
#undef GTEST_7_TUPLE_ | |||||
#undef GTEST_8_TUPLE_ | |||||
#undef GTEST_9_TUPLE_ | |||||
#undef GTEST_10_TUPLE_ | |||||
#undef GTEST_0_TYPENAMES_ | |||||
#undef GTEST_1_TYPENAMES_ | |||||
#undef GTEST_2_TYPENAMES_ | |||||
#undef GTEST_3_TYPENAMES_ | |||||
#undef GTEST_4_TYPENAMES_ | |||||
#undef GTEST_5_TYPENAMES_ | |||||
#undef GTEST_6_TYPENAMES_ | |||||
#undef GTEST_7_TYPENAMES_ | |||||
#undef GTEST_8_TYPENAMES_ | |||||
#undef GTEST_9_TYPENAMES_ | |||||
#undef GTEST_10_TYPENAMES_ | |||||
#undef GTEST_DECLARE_TUPLE_AS_FRIEND_ | |||||
#undef GTEST_BY_REF_ | |||||
#undef GTEST_ADD_REF_ | |||||
#undef GTEST_TUPLE_ELEMENT_ | |||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ |