| $$ -*- 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 <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 |
| // 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 <GTEST_$(n)_TYPENAMES_(U)> friend class tuple; \ |
| private: |
| #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<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; |
| |
| |
| $for i [[ |
| template <GTEST_$(n)_TYPENAMES_(T)> |
| struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T)> [[]] |
| { 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 <GTEST_$(k)_TYPENAMES_(T)> |
| class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] { |
| public: |
| template <int k> 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 <GTEST_$(k)_TYPENAMES_(U)> |
| tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {} |
| |
| $if k == 2 [[ |
| 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_$(k)_TYPENAMES_(U)> |
| tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) { |
| return CopyFrom(t); |
| } |
| |
| $if k == 2 [[ |
| 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_$(k)_TYPENAMES_(U)> |
| 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<T> to make_tuple(). And we don't |
| // implement tie(). |
| |
| inline tuple<> make_tuple() { return tuple<>(); } |
| |
| $for k [[ |
| $range m 0..k-1 |
| |
| template <GTEST_$(k)_TYPENAMES_(T)> |
| 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 <typename Tuple> struct tuple_size; |
| |
| |
| $for j [[ |
| template <GTEST_$(j)_TYPENAMES_(T)> |
| struct tuple_size<GTEST_$(j)_TUPLE_(T)> { static const int value = $j; }; |
| |
| |
| ]] |
| 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 { |
| |
| |
| $for i [[ |
| template <> |
| class Get<$i> { |
| public: |
| template <class Tuple> |
| static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple)) |
| Field(Tuple& t) { return t.f$(i)_; } // NOLINT |
| |
| template <class Tuple> |
| static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple)) |
| ConstField(const Tuple& t) { return t.f$(i)_; } |
| }; |
| |
| |
| ]] |
| } // namespace gtest_internal |
| |
| template <int k, GTEST_$(n)_TYPENAMES_(T)> |
| GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T))) |
| get(GTEST_$(n)_TUPLE_(T)& t) { |
| return gtest_internal::Get<k>::Field(t); |
| } |
| |
| template <int k, GTEST_$(n)_TYPENAMES_(T)> |
| GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T))) |
| get(const GTEST_$(n)_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_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)> |
| inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t, |
| const GTEST_$(n)_TUPLE_(U)& u) { |
| return gtest_internal::SameSizeTuplePrefixComparator< |
| tuple_size<GTEST_$(n)_TUPLE_(T)>::value, |
| tuple_size<GTEST_$(n)_TUPLE_(U)>::value>::Eq(t, u); |
| } |
| |
| template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)> |
| 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_ |