Subversion Repositories s80186

$$ -*- mode: c++; -*-

$var n = 10  $$ Maximum number of tuple fields we want to support.

$$ This meta comment fixes auto-indentation in Emacs. }}

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

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

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

$range i 0..n-1

$range j 0..n

$range k 1..n

// GTEST_n_TUPLE_(T) is the type of an n-tuple.

#define GTEST_0_TUPLE_(T) tuple<>

$for k [[

$range m 0..k-1

$range m2 k..n-1

#define GTEST_$(k)_TUPLE_(T) tuple<$for m, [[T##$m]]$for m2 [[, void]]>

]]

// GTEST_n_TYPENAMES_(T) declares a list of n typenames.

$for j [[

$range m 0..j-1

#define GTEST_$(j)_TYPENAMES_(T) $for m, [[typename T##$m]]

]]

// 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 <$for i, [[typename T$i = 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::type is T if T is a reference; otherwise it's const T&.

template 

struct ByRef { typedef const T& type; };  // NOLINT

template 

struct ByRef { typedef T& type; };  // NOLINT

// A handy wrapper for ByRef.

#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef::type

// AddRef::type is T if T is a reference; otherwise it's T&.  This

// is the same as tr1::add_reference::type.

template 

struct AddRef { typedef T& type; };  // NOLINT

template 

struct AddRef { typedef T& type; };  // NOLINT

// A handy wrapper for AddRef.

#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef::type

// A helper for implementing get().

template  class Get;

// A helper for implementing tuple_element.  kIndexValid is true

// iff k < the number of fields in tuple type T.

template 

struct TupleElement;

$for i [[

template 

struct TupleElement {

  typedef T$i type;

};

]]

}  // namespace gtest_internal

template <>

class tuple<> {

 public:

  tuple() {}

  tuple(const tuple& /* t */)  {}

  tuple& operator=(const tuple& /* t */) { return *this; }

};

$for k [[

$range m 0..k-1

template 

class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] {

 public:

  template  friend class gtest_internal::Get;

  tuple() : $for m, [[f$(m)_()]] {}

  explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]]

$for m, [[f$(m)_(f$m)]] {}

  tuple(const tuple& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}

  template 

  tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {}

$if k == 2 [[

  template 

  tuple(const ::std::pair& p) : f0_(p.first), f1_(p.second) {}

]]

  tuple& operator=(const tuple& t) { return CopyFrom(t); }

  template 

  tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) {

    return CopyFrom(t);

  }

$if k == 2 [[

  template 

  tuple& operator=(const ::std::pair& p) {

    f0_ = p.first;

    f1_ = p.second;

    return *this;

  }

]]

  GTEST_DECLARE_TUPLE_AS_FRIEND_

  template 

  tuple& CopyFrom(const GTEST_$(k)_TUPLE_(U)& t) {

$for m [[

    f$(m)_ = t.f$(m)_;

]]

    return *this;

  }

$for m [[

  T$m f$(m)_;

]]

};

]]

// 6.1.3.2 Tuple creation functions.

// Known limitations: we don't support passing an

// std::tr1::reference_wrapper to make_tuple().  And we don't

// implement tie().

inline tuple<> make_tuple() { return tuple<>(); }

$for k [[

$range m 0..k-1

template 

inline GTEST_$(k)_TUPLE_(T) make_tuple($for m, [[const T$m& f$m]]) {

  return GTEST_$(k)_TUPLE_(T)($for m, [[f$m]]);

}

]]

// 6.1.3.3 Tuple helper classes.

template  struct tuple_size;

$for j [[

template 

struct tuple_size {

  static const int value = $j;

};

]]

template 

struct tuple_element {

  typedef typename gtest_internal::TupleElement<

      k < (tuple_size::value), k, Tuple>::type type;

};

#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element::type

// 6.1.3.4 Element access.

namespace gtest_internal {

$for i [[

template <>

class Get<$i> {

 public:

  template 

  static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))

  Field(Tuple& t) { return t.f$(i)_; }  // NOLINT

  template 

  static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple))

  ConstField(const Tuple& t) { return t.f$(i)_; }

};

]]

}  // namespace gtest_internal

template 

GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T)))

get(GTEST_$(n)_TUPLE_(T)& t) {

  return gtest_internal::Get::Field(t);

}

template 

GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k,  GTEST_$(n)_TUPLE_(T)))

get(const GTEST_$(n)_TUPLE_(T)& t) {

  return gtest_internal::Get::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::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 

struct SameSizeTuplePrefixComparator;

template <>

struct SameSizeTuplePrefixComparator<0, 0> {

  template 

  static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {

    return true;

  }

};

template 

struct SameSizeTuplePrefixComparator {

  template 

  static bool Eq(const Tuple1& t1, const Tuple2& t2) {

    return SameSizeTuplePrefixComparator::Eq(t1, t2) &&

        ::std::tr1::get(t1) == ::std::tr1::get(t2);

  }

};

}  // namespace gtest_internal

template 

inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t,

                       const GTEST_$(n)_TUPLE_(U)& u) {

  return gtest_internal::SameSizeTuplePrefixComparator<

      tuple_size::value,

      tuple_size::value>::Eq(t, u);

}

template 

inline bool operator!=(const GTEST_$(n)_TUPLE_(T)& t,

                       const GTEST_$(n)_TUPLE_(U)& u) { return !(t == u); }

// 6.1.4 Pairs.

// Unimplemented.

}  // namespace tr1

}  // namespace std

$for j [[

#undef GTEST_$(j)_TUPLE_

]]

$for j [[

#undef GTEST_$(j)_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_