protobuff在vs2010下编译时错误：'type'

protobuff在vs2010下编译时提示：'type' : is not a member of'std::tr1::tuple_element'错误

 

这个错误是google开发人员引起的，暂时还没有推出解决此问题的版本包，但是他们提供了两个方案，两方案都能编译通过，但还会有两个警告，暂时未发现影响

1 在gtest-port.h中将GTEST_USE_OWN_TR1_TUPLE=1改为GTEST_USE_OWN_TR1_TUPLE=0

2  替换gtest-tuple.h，下载地址为http://code.google.com/p/googletest/issues/detail?id=217最下面的download。

也可直接使用下面的代码替换（以下代码即提供的新程序）

// This file was GENERATED by a script.  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.

//

// Author: wan@google.com (Zhanyong Wan)

// Implements a subset of TR1 tuple needed by Google Test and Google Mock.

#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_

#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_

#if _MSC_VER < 1600

#include<utility>  // For ::std::pair.

//.. also define tuple below for <=VS2008

#else

#include<tuple> //VS010

#endif

// 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

// hack bypasses the bug by declaring the members that should otherwise be

// private as public.

#if defined(__SYMBIAN32__)

#define GTEST_DECLARE_TUPLE_AS_FRIEND_public:

#else

#define GTEST_DECLARE_TUPLE_AS_FRIEND_\

template<GTEST_10_TYPENAMES_(U)>friend class tuple;\

private:

#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

#if _MSC_VER < 1600

// 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{ typedefconst 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(){}

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){ returnCopyFrom(t);}

template<GTEST_1_TYPENAMES_(U)>

tuple&operator=(const GTEST_1_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_2_TYPENAMES_(U)>

tuple&operator=(const GTEST_2_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_3_TYPENAMES_(U)>

tuple&operator=(const GTEST_3_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_4_TYPENAMES_(U)>

tuple&operator=(const GTEST_4_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_5_TYPENAMES_(U)>

tuple&operator=(const GTEST_5_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_6_TYPENAMES_(U)>

tuple&operator=(const GTEST_6_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_7_TYPENAMES_(U)>

tuple&operator=(const GTEST_7_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_8_TYPENAMES_(U)>

tuple&operator=(const GTEST_8_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_9_TYPENAMES_(U)>

tuple&operator=(const GTEST_9_TUPLE_(U)& t){

returnCopyFrom(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(){}

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){ returnCopyFrom(t);}

template<GTEST_10_TYPENAMES_(U)>

tuple&operator=(const GTEST_10_TUPLE_(U)& t){

returnCopyFrom(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 <typenameTuple>struct tuple_size;

template <GTEST_0_TYPENAMES_(T)>

struct tuple_size<GTEST_0_TUPLE_(T)>{ staticconst int value= 0;};

template <GTEST_1_TYPENAMES_(T)>

struct tuple_size<GTEST_1_TUPLE_(T)>{ staticconst int value= 1;};

template <GTEST_2_TYPENAMES_(T)>

struct tuple_size<GTEST_2_TUPLE_(T)>{ staticconst int value= 2;};

template <GTEST_3_TYPENAMES_(T)>

struct tuple_size<GTEST_3_TUPLE_(T)>{ staticconst int value= 3;};

template <GTEST_4_TYPENAMES_(T)>

struct tuple_size<GTEST_4_TUPLE_(T)>{ staticconst int value= 4;};

template <GTEST_5_TYPENAMES_(T)>

struct tuple_size<GTEST_5_TUPLE_(T)>{ staticconst int value= 5;};

template <GTEST_6_TYPENAMES_(T)>

struct tuple_size<GTEST_6_TUPLE_(T)>{ staticconst int value= 6;};

template <GTEST_7_TYPENAMES_(T)>

struct tuple_size<GTEST_7_TUPLE_(T)>{ staticconst int value= 7;};

template <GTEST_8_TYPENAMES_(T)>

struct tuple_size<GTEST_8_TUPLE_(T)>{ staticconst int value= 8;};

template <GTEST_9_TYPENAMES_(T)>

struct tuple_size<GTEST_9_TUPLE_(T)>{ staticconst int value= 9;};

template <GTEST_10_TYPENAMES_(T)>

struct tuple_size<GTEST_10_TUPLE_(T)>{ staticconst int value= 10;};

template <int k,class Tuple>

struct tuple_element{

typedeftypename 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<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0,Tuple))

Field(Tuple& t){ return t.f0_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0,Tuple))

ConstField(constTuple& t){ return t.f0_;}

};

template <>

class Get<1>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1,Tuple))

Field(Tuple& t){ return t.f1_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1,Tuple))

ConstField(constTuple& t){ return t.f1_;}

};

template <>

class Get<2>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2,Tuple))

Field(Tuple& t){ return t.f2_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2,Tuple))

ConstField(constTuple& t){ return t.f2_;}

};

template <>

class Get<3>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3,Tuple))

Field(Tuple& t){ return t.f3_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3,Tuple))

ConstField(constTuple& t){ return t.f3_;}

};

template <>

class Get<4>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4,Tuple))

Field(Tuple& t){ return t.f4_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4,Tuple))

ConstField(constTuple& t){ return t.f4_;}

};

template <>

class Get<5>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5,Tuple))

Field(Tuple& t){ return t.f5_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5,Tuple))

ConstField(constTuple& t){ return t.f5_;}

};

template <>

class Get<6>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6,Tuple))

Field(Tuple& t){ return t.f6_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6,Tuple))

ConstField(constTuple& t){ return t.f6_;}

};

template <>

class Get<7>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7,Tuple))

Field(Tuple& t){ return t.f7_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7,Tuple))

ConstField(constTuple& t){ return t.f7_;}

};

template <>

class Get<8>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8,Tuple))

Field(Tuple& t){ return t.f8_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8,Tuple))

ConstField(constTuple& t){ return t.f8_;}

};

template <>

class Get<9>{

public:

template<classTuple>

static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9,Tuple))

Field(Tuple& t){ return t.f9_;}  // NOLINT

template<classTuple>

static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9,Tuple))

ConstField(constTuple& 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<classTuple1,class Tuple2>

staticbool Eq(constTuple1&/* t1 */,const Tuple2&/* t2 */){

returntrue;

}

};

template <int k>

struct SameSizeTuplePrefixComparator<k, k>{

template<classTuple1,class Tuple2>

staticbool Eq(constTuple1& t1,const Tuple2& t2){

returnSameSizeTuplePrefixComparator<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 booloperator==(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 booloperator!=(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  // _MFC_VER 0x0A00

#endif  // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_