/Unittests/googletest/include/gtest/internal/gtest-tuple.h

http://unladen-swallow.googlecode.com/ · C++ Header · 966 lines · 705 code · 196 blank · 65 comment · 2 complexity · c01d6cf281d8c513606328274a6e9da9 MD5 · raw file

  1. // This file was GENERATED by a script. DO NOT EDIT BY HAND!!!
  2. // Copyright 2009 Google Inc.
  3. // All Rights Reserved.
  4. //
  5. // Redistribution and use in source and binary forms, with or without
  6. // modification, are permitted provided that the following conditions are
  7. // met:
  8. //
  9. // * Redistributions of source code must retain the above copyright
  10. // notice, this list of conditions and the following disclaimer.
  11. // * Redistributions in binary form must reproduce the above
  12. // copyright notice, this list of conditions and the following disclaimer
  13. // in the documentation and/or other materials provided with the
  14. // distribution.
  15. // * Neither the name of Google Inc. nor the names of its
  16. // contributors may be used to endorse or promote products derived from
  17. // this software without specific prior written permission.
  18. //
  19. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30. //
  31. // Author: wan@google.com (Zhanyong Wan)
  32. // Implements a subset of TR1 tuple needed by Google Test and Google Mock.
  33. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
  34. #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_
  35. #include <utility> // For ::std::pair.
  36. // The compiler used in Symbian has a bug that prevents us from declaring the
  37. // tuple template as a friend (it complains that tuple is redefined). This
  38. // hack bypasses the bug by declaring the members that should otherwise be
  39. // private as public.
  40. #if defined(__SYMBIAN32__)
  41. #define GTEST_DECLARE_TUPLE_AS_FRIEND_ public:
  42. #else
  43. #define GTEST_DECLARE_TUPLE_AS_FRIEND_ \
  44. template <GTEST_10_TYPENAMES_(U)> friend class tuple; \
  45. private:
  46. #endif
  47. // GTEST_n_TUPLE_(T) is the type of an n-tuple.
  48. #define GTEST_0_TUPLE_(T) tuple<>
  49. #define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \
  50. void, void, void>
  51. #define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \
  52. void, void, void>
  53. #define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \
  54. void, void, void>
  55. #define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \
  56. void, void, void>
  57. #define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \
  58. void, void, void>
  59. #define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \
  60. void, void, void>
  61. #define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
  62. void, void, void>
  63. #define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
  64. T##7, void, void>
  65. #define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
  66. T##7, T##8, void>
  67. #define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \
  68. T##7, T##8, T##9>
  69. // GTEST_n_TYPENAMES_(T) declares a list of n typenames.
  70. #define GTEST_0_TYPENAMES_(T)
  71. #define GTEST_1_TYPENAMES_(T) typename T##0
  72. #define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1
  73. #define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2
  74. #define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  75. typename T##3
  76. #define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  77. typename T##3, typename T##4
  78. #define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  79. typename T##3, typename T##4, typename T##5
  80. #define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  81. typename T##3, typename T##4, typename T##5, typename T##6
  82. #define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  83. typename T##3, typename T##4, typename T##5, typename T##6, typename T##7
  84. #define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  85. typename T##3, typename T##4, typename T##5, typename T##6, \
  86. typename T##7, typename T##8
  87. #define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \
  88. typename T##3, typename T##4, typename T##5, typename T##6, \
  89. typename T##7, typename T##8, typename T##9
  90. // In theory, defining stuff in the ::std namespace is undefined
  91. // behavior. We can do this as we are playing the role of a standard
  92. // library vendor.
  93. namespace std {
  94. namespace tr1 {
  95. template <typename T0 = void, typename T1 = void, typename T2 = void,
  96. typename T3 = void, typename T4 = void, typename T5 = void,
  97. typename T6 = void, typename T7 = void, typename T8 = void,
  98. typename T9 = void>
  99. class tuple;
  100. // Anything in namespace gtest_internal is Google Test's INTERNAL
  101. // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code.
  102. namespace gtest_internal {
  103. // ByRef<T>::type is T if T is a reference; otherwise it's const T&.
  104. template <typename T>
  105. struct ByRef { typedef const T& type; }; // NOLINT
  106. template <typename T>
  107. struct ByRef<T&> { typedef T& type; }; // NOLINT
  108. // A handy wrapper for ByRef.
  109. #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type
  110. // AddRef<T>::type is T if T is a reference; otherwise it's T&. This
  111. // is the same as tr1::add_reference<T>::type.
  112. template <typename T>
  113. struct AddRef { typedef T& type; }; // NOLINT
  114. template <typename T>
  115. struct AddRef<T&> { typedef T& type; }; // NOLINT
  116. // A handy wrapper for AddRef.
  117. #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type
  118. // A helper for implementing get<k>().
  119. template <int k> class Get;
  120. // A helper for implementing tuple_element<k, T>. kIndexValid is true
  121. // iff k < the number of fields in tuple type T.
  122. template <bool kIndexValid, int kIndex, class Tuple>
  123. struct TupleElement;
  124. template <GTEST_10_TYPENAMES_(T)>
  125. struct TupleElement<true, 0, GTEST_10_TUPLE_(T)> { typedef T0 type; };
  126. template <GTEST_10_TYPENAMES_(T)>
  127. struct TupleElement<true, 1, GTEST_10_TUPLE_(T)> { typedef T1 type; };
  128. template <GTEST_10_TYPENAMES_(T)>
  129. struct TupleElement<true, 2, GTEST_10_TUPLE_(T)> { typedef T2 type; };
  130. template <GTEST_10_TYPENAMES_(T)>
  131. struct TupleElement<true, 3, GTEST_10_TUPLE_(T)> { typedef T3 type; };
  132. template <GTEST_10_TYPENAMES_(T)>
  133. struct TupleElement<true, 4, GTEST_10_TUPLE_(T)> { typedef T4 type; };
  134. template <GTEST_10_TYPENAMES_(T)>
  135. struct TupleElement<true, 5, GTEST_10_TUPLE_(T)> { typedef T5 type; };
  136. template <GTEST_10_TYPENAMES_(T)>
  137. struct TupleElement<true, 6, GTEST_10_TUPLE_(T)> { typedef T6 type; };
  138. template <GTEST_10_TYPENAMES_(T)>
  139. struct TupleElement<true, 7, GTEST_10_TUPLE_(T)> { typedef T7 type; };
  140. template <GTEST_10_TYPENAMES_(T)>
  141. struct TupleElement<true, 8, GTEST_10_TUPLE_(T)> { typedef T8 type; };
  142. template <GTEST_10_TYPENAMES_(T)>
  143. struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> { typedef T9 type; };
  144. } // namespace gtest_internal
  145. template <>
  146. class tuple<> {
  147. public:
  148. tuple() {}
  149. tuple(const tuple& /* t */) {}
  150. tuple& operator=(const tuple& /* t */) { return *this; }
  151. };
  152. template <GTEST_1_TYPENAMES_(T)>
  153. class GTEST_1_TUPLE_(T) {
  154. public:
  155. template <int k> friend class gtest_internal::Get;
  156. tuple() {}
  157. explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {}
  158. tuple(const tuple& t) : f0_(t.f0_) {}
  159. template <GTEST_1_TYPENAMES_(U)>
  160. tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {}
  161. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  162. template <GTEST_1_TYPENAMES_(U)>
  163. tuple& operator=(const GTEST_1_TUPLE_(U)& t) {
  164. return CopyFrom(t);
  165. }
  166. GTEST_DECLARE_TUPLE_AS_FRIEND_
  167. template <GTEST_1_TYPENAMES_(U)>
  168. tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) {
  169. f0_ = t.f0_;
  170. return *this;
  171. }
  172. T0 f0_;
  173. };
  174. template <GTEST_2_TYPENAMES_(T)>
  175. class GTEST_2_TUPLE_(T) {
  176. public:
  177. template <int k> friend class gtest_internal::Get;
  178. tuple() {}
  179. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0),
  180. f1_(f1) {}
  181. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {}
  182. template <GTEST_2_TYPENAMES_(U)>
  183. tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {}
  184. template <typename U0, typename U1>
  185. tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {}
  186. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  187. template <GTEST_2_TYPENAMES_(U)>
  188. tuple& operator=(const GTEST_2_TUPLE_(U)& t) {
  189. return CopyFrom(t);
  190. }
  191. template <typename U0, typename U1>
  192. tuple& operator=(const ::std::pair<U0, U1>& p) {
  193. f0_ = p.first;
  194. f1_ = p.second;
  195. return *this;
  196. }
  197. GTEST_DECLARE_TUPLE_AS_FRIEND_
  198. template <GTEST_2_TYPENAMES_(U)>
  199. tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) {
  200. f0_ = t.f0_;
  201. f1_ = t.f1_;
  202. return *this;
  203. }
  204. T0 f0_;
  205. T1 f1_;
  206. };
  207. template <GTEST_3_TYPENAMES_(T)>
  208. class GTEST_3_TUPLE_(T) {
  209. public:
  210. template <int k> friend class gtest_internal::Get;
  211. tuple() {}
  212. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  213. GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {}
  214. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
  215. template <GTEST_3_TYPENAMES_(U)>
  216. tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {}
  217. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  218. template <GTEST_3_TYPENAMES_(U)>
  219. tuple& operator=(const GTEST_3_TUPLE_(U)& t) {
  220. return CopyFrom(t);
  221. }
  222. GTEST_DECLARE_TUPLE_AS_FRIEND_
  223. template <GTEST_3_TYPENAMES_(U)>
  224. tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) {
  225. f0_ = t.f0_;
  226. f1_ = t.f1_;
  227. f2_ = t.f2_;
  228. return *this;
  229. }
  230. T0 f0_;
  231. T1 f1_;
  232. T2 f2_;
  233. };
  234. template <GTEST_4_TYPENAMES_(T)>
  235. class GTEST_4_TUPLE_(T) {
  236. public:
  237. template <int k> friend class gtest_internal::Get;
  238. tuple() {}
  239. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  240. GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2),
  241. f3_(f3) {}
  242. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {}
  243. template <GTEST_4_TYPENAMES_(U)>
  244. tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  245. f3_(t.f3_) {}
  246. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  247. template <GTEST_4_TYPENAMES_(U)>
  248. tuple& operator=(const GTEST_4_TUPLE_(U)& t) {
  249. return CopyFrom(t);
  250. }
  251. GTEST_DECLARE_TUPLE_AS_FRIEND_
  252. template <GTEST_4_TYPENAMES_(U)>
  253. tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) {
  254. f0_ = t.f0_;
  255. f1_ = t.f1_;
  256. f2_ = t.f2_;
  257. f3_ = t.f3_;
  258. return *this;
  259. }
  260. T0 f0_;
  261. T1 f1_;
  262. T2 f2_;
  263. T3 f3_;
  264. };
  265. template <GTEST_5_TYPENAMES_(T)>
  266. class GTEST_5_TUPLE_(T) {
  267. public:
  268. template <int k> friend class gtest_internal::Get;
  269. tuple() {}
  270. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  271. GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3,
  272. GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {}
  273. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  274. f4_(t.f4_) {}
  275. template <GTEST_5_TYPENAMES_(U)>
  276. tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  277. f3_(t.f3_), f4_(t.f4_) {}
  278. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  279. template <GTEST_5_TYPENAMES_(U)>
  280. tuple& operator=(const GTEST_5_TUPLE_(U)& t) {
  281. return CopyFrom(t);
  282. }
  283. GTEST_DECLARE_TUPLE_AS_FRIEND_
  284. template <GTEST_5_TYPENAMES_(U)>
  285. tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) {
  286. f0_ = t.f0_;
  287. f1_ = t.f1_;
  288. f2_ = t.f2_;
  289. f3_ = t.f3_;
  290. f4_ = t.f4_;
  291. return *this;
  292. }
  293. T0 f0_;
  294. T1 f1_;
  295. T2 f2_;
  296. T3 f3_;
  297. T4 f4_;
  298. };
  299. template <GTEST_6_TYPENAMES_(T)>
  300. class GTEST_6_TUPLE_(T) {
  301. public:
  302. template <int k> friend class gtest_internal::Get;
  303. tuple() {}
  304. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  305. GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  306. GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
  307. f5_(f5) {}
  308. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  309. f4_(t.f4_), f5_(t.f5_) {}
  310. template <GTEST_6_TYPENAMES_(U)>
  311. tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  312. f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {}
  313. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  314. template <GTEST_6_TYPENAMES_(U)>
  315. tuple& operator=(const GTEST_6_TUPLE_(U)& t) {
  316. return CopyFrom(t);
  317. }
  318. GTEST_DECLARE_TUPLE_AS_FRIEND_
  319. template <GTEST_6_TYPENAMES_(U)>
  320. tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) {
  321. f0_ = t.f0_;
  322. f1_ = t.f1_;
  323. f2_ = t.f2_;
  324. f3_ = t.f3_;
  325. f4_ = t.f4_;
  326. f5_ = t.f5_;
  327. return *this;
  328. }
  329. T0 f0_;
  330. T1 f1_;
  331. T2 f2_;
  332. T3 f3_;
  333. T4 f4_;
  334. T5 f5_;
  335. };
  336. template <GTEST_7_TYPENAMES_(T)>
  337. class GTEST_7_TUPLE_(T) {
  338. public:
  339. template <int k> friend class gtest_internal::Get;
  340. tuple() {}
  341. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  342. GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  343. GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2),
  344. f3_(f3), f4_(f4), f5_(f5), f6_(f6) {}
  345. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  346. f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
  347. template <GTEST_7_TYPENAMES_(U)>
  348. tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  349. f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {}
  350. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  351. template <GTEST_7_TYPENAMES_(U)>
  352. tuple& operator=(const GTEST_7_TUPLE_(U)& t) {
  353. return CopyFrom(t);
  354. }
  355. GTEST_DECLARE_TUPLE_AS_FRIEND_
  356. template <GTEST_7_TYPENAMES_(U)>
  357. tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) {
  358. f0_ = t.f0_;
  359. f1_ = t.f1_;
  360. f2_ = t.f2_;
  361. f3_ = t.f3_;
  362. f4_ = t.f4_;
  363. f5_ = t.f5_;
  364. f6_ = t.f6_;
  365. return *this;
  366. }
  367. T0 f0_;
  368. T1 f1_;
  369. T2 f2_;
  370. T3 f3_;
  371. T4 f4_;
  372. T5 f5_;
  373. T6 f6_;
  374. };
  375. template <GTEST_8_TYPENAMES_(T)>
  376. class GTEST_8_TUPLE_(T) {
  377. public:
  378. template <int k> friend class gtest_internal::Get;
  379. tuple() {}
  380. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  381. GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  382. GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6,
  383. GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
  384. f5_(f5), f6_(f6), f7_(f7) {}
  385. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  386. f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
  387. template <GTEST_8_TYPENAMES_(U)>
  388. tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  389. f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {}
  390. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  391. template <GTEST_8_TYPENAMES_(U)>
  392. tuple& operator=(const GTEST_8_TUPLE_(U)& t) {
  393. return CopyFrom(t);
  394. }
  395. GTEST_DECLARE_TUPLE_AS_FRIEND_
  396. template <GTEST_8_TYPENAMES_(U)>
  397. tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) {
  398. f0_ = t.f0_;
  399. f1_ = t.f1_;
  400. f2_ = t.f2_;
  401. f3_ = t.f3_;
  402. f4_ = t.f4_;
  403. f5_ = t.f5_;
  404. f6_ = t.f6_;
  405. f7_ = t.f7_;
  406. return *this;
  407. }
  408. T0 f0_;
  409. T1 f1_;
  410. T2 f2_;
  411. T3 f3_;
  412. T4 f4_;
  413. T5 f5_;
  414. T6 f6_;
  415. T7 f7_;
  416. };
  417. template <GTEST_9_TYPENAMES_(T)>
  418. class GTEST_9_TUPLE_(T) {
  419. public:
  420. template <int k> friend class gtest_internal::Get;
  421. tuple() {}
  422. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  423. GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  424. GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
  425. GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4),
  426. f5_(f5), f6_(f6), f7_(f7), f8_(f8) {}
  427. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  428. f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
  429. template <GTEST_9_TYPENAMES_(U)>
  430. tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  431. f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {}
  432. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  433. template <GTEST_9_TYPENAMES_(U)>
  434. tuple& operator=(const GTEST_9_TUPLE_(U)& t) {
  435. return CopyFrom(t);
  436. }
  437. GTEST_DECLARE_TUPLE_AS_FRIEND_
  438. template <GTEST_9_TYPENAMES_(U)>
  439. tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) {
  440. f0_ = t.f0_;
  441. f1_ = t.f1_;
  442. f2_ = t.f2_;
  443. f3_ = t.f3_;
  444. f4_ = t.f4_;
  445. f5_ = t.f5_;
  446. f6_ = t.f6_;
  447. f7_ = t.f7_;
  448. f8_ = t.f8_;
  449. return *this;
  450. }
  451. T0 f0_;
  452. T1 f1_;
  453. T2 f2_;
  454. T3 f3_;
  455. T4 f4_;
  456. T5 f5_;
  457. T6 f6_;
  458. T7 f7_;
  459. T8 f8_;
  460. };
  461. template <GTEST_10_TYPENAMES_(T)>
  462. class tuple {
  463. public:
  464. template <int k> friend class gtest_internal::Get;
  465. tuple() {}
  466. explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1,
  467. GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4,
  468. GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7,
  469. GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2),
  470. f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {}
  471. tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_),
  472. f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {}
  473. template <GTEST_10_TYPENAMES_(U)>
  474. tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_),
  475. f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_),
  476. f9_(t.f9_) {}
  477. tuple& operator=(const tuple& t) { return CopyFrom(t); }
  478. template <GTEST_10_TYPENAMES_(U)>
  479. tuple& operator=(const GTEST_10_TUPLE_(U)& t) {
  480. return CopyFrom(t);
  481. }
  482. GTEST_DECLARE_TUPLE_AS_FRIEND_
  483. template <GTEST_10_TYPENAMES_(U)>
  484. tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) {
  485. f0_ = t.f0_;
  486. f1_ = t.f1_;
  487. f2_ = t.f2_;
  488. f3_ = t.f3_;
  489. f4_ = t.f4_;
  490. f5_ = t.f5_;
  491. f6_ = t.f6_;
  492. f7_ = t.f7_;
  493. f8_ = t.f8_;
  494. f9_ = t.f9_;
  495. return *this;
  496. }
  497. T0 f0_;
  498. T1 f1_;
  499. T2 f2_;
  500. T3 f3_;
  501. T4 f4_;
  502. T5 f5_;
  503. T6 f6_;
  504. T7 f7_;
  505. T8 f8_;
  506. T9 f9_;
  507. };
  508. // 6.1.3.2 Tuple creation functions.
  509. // Known limitations: we don't support passing an
  510. // std::tr1::reference_wrapper<T> to make_tuple(). And we don't
  511. // implement tie().
  512. inline tuple<> make_tuple() { return tuple<>(); }
  513. template <GTEST_1_TYPENAMES_(T)>
  514. inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) {
  515. return GTEST_1_TUPLE_(T)(f0);
  516. }
  517. template <GTEST_2_TYPENAMES_(T)>
  518. inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
  519. return GTEST_2_TUPLE_(T)(f0, f1);
  520. }
  521. template <GTEST_3_TYPENAMES_(T)>
  522. inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
  523. return GTEST_3_TUPLE_(T)(f0, f1, f2);
  524. }
  525. template <GTEST_4_TYPENAMES_(T)>
  526. inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  527. const T3& f3) {
  528. return GTEST_4_TUPLE_(T)(f0, f1, f2, f3);
  529. }
  530. template <GTEST_5_TYPENAMES_(T)>
  531. inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  532. const T3& f3, const T4& f4) {
  533. return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4);
  534. }
  535. template <GTEST_6_TYPENAMES_(T)>
  536. inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  537. const T3& f3, const T4& f4, const T5& f5) {
  538. return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5);
  539. }
  540. template <GTEST_7_TYPENAMES_(T)>
  541. inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  542. const T3& f3, const T4& f4, const T5& f5, const T6& f6) {
  543. return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6);
  544. }
  545. template <GTEST_8_TYPENAMES_(T)>
  546. inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  547. const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) {
  548. return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7);
  549. }
  550. template <GTEST_9_TYPENAMES_(T)>
  551. inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  552. const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
  553. const T8& f8) {
  554. return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8);
  555. }
  556. template <GTEST_10_TYPENAMES_(T)>
  557. inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  558. const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7,
  559. const T8& f8, const T9& f9) {
  560. return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9);
  561. }
  562. // 6.1.3.3 Tuple helper classes.
  563. template <typename Tuple> struct tuple_size;
  564. template <GTEST_0_TYPENAMES_(T)>
  565. struct tuple_size<GTEST_0_TUPLE_(T)> { static const int value = 0; };
  566. template <GTEST_1_TYPENAMES_(T)>
  567. struct tuple_size<GTEST_1_TUPLE_(T)> { static const int value = 1; };
  568. template <GTEST_2_TYPENAMES_(T)>
  569. struct tuple_size<GTEST_2_TUPLE_(T)> { static const int value = 2; };
  570. template <GTEST_3_TYPENAMES_(T)>
  571. struct tuple_size<GTEST_3_TUPLE_(T)> { static const int value = 3; };
  572. template <GTEST_4_TYPENAMES_(T)>
  573. struct tuple_size<GTEST_4_TUPLE_(T)> { static const int value = 4; };
  574. template <GTEST_5_TYPENAMES_(T)>
  575. struct tuple_size<GTEST_5_TUPLE_(T)> { static const int value = 5; };
  576. template <GTEST_6_TYPENAMES_(T)>
  577. struct tuple_size<GTEST_6_TUPLE_(T)> { static const int value = 6; };
  578. template <GTEST_7_TYPENAMES_(T)>
  579. struct tuple_size<GTEST_7_TUPLE_(T)> { static const int value = 7; };
  580. template <GTEST_8_TYPENAMES_(T)>
  581. struct tuple_size<GTEST_8_TUPLE_(T)> { static const int value = 8; };
  582. template <GTEST_9_TYPENAMES_(T)>
  583. struct tuple_size<GTEST_9_TUPLE_(T)> { static const int value = 9; };
  584. template <GTEST_10_TYPENAMES_(T)>
  585. struct tuple_size<GTEST_10_TUPLE_(T)> { static const int value = 10; };
  586. template <int k, class Tuple>
  587. struct tuple_element {
  588. typedef typename gtest_internal::TupleElement<
  589. k < (tuple_size<Tuple>::value), k, Tuple>::type type;
  590. };
  591. #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type
  592. // 6.1.3.4 Element access.
  593. namespace gtest_internal {
  594. template <>
  595. class Get<0> {
  596. public:
  597. template <class Tuple>
  598. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
  599. Field(Tuple& t) { return t.f0_; } // NOLINT
  600. template <class Tuple>
  601. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple))
  602. ConstField(const Tuple& t) { return t.f0_; }
  603. };
  604. template <>
  605. class Get<1> {
  606. public:
  607. template <class Tuple>
  608. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
  609. Field(Tuple& t) { return t.f1_; } // NOLINT
  610. template <class Tuple>
  611. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple))
  612. ConstField(const Tuple& t) { return t.f1_; }
  613. };
  614. template <>
  615. class Get<2> {
  616. public:
  617. template <class Tuple>
  618. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
  619. Field(Tuple& t) { return t.f2_; } // NOLINT
  620. template <class Tuple>
  621. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple))
  622. ConstField(const Tuple& t) { return t.f2_; }
  623. };
  624. template <>
  625. class Get<3> {
  626. public:
  627. template <class Tuple>
  628. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
  629. Field(Tuple& t) { return t.f3_; } // NOLINT
  630. template <class Tuple>
  631. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple))
  632. ConstField(const Tuple& t) { return t.f3_; }
  633. };
  634. template <>
  635. class Get<4> {
  636. public:
  637. template <class Tuple>
  638. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
  639. Field(Tuple& t) { return t.f4_; } // NOLINT
  640. template <class Tuple>
  641. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple))
  642. ConstField(const Tuple& t) { return t.f4_; }
  643. };
  644. template <>
  645. class Get<5> {
  646. public:
  647. template <class Tuple>
  648. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
  649. Field(Tuple& t) { return t.f5_; } // NOLINT
  650. template <class Tuple>
  651. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple))
  652. ConstField(const Tuple& t) { return t.f5_; }
  653. };
  654. template <>
  655. class Get<6> {
  656. public:
  657. template <class Tuple>
  658. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
  659. Field(Tuple& t) { return t.f6_; } // NOLINT
  660. template <class Tuple>
  661. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple))
  662. ConstField(const Tuple& t) { return t.f6_; }
  663. };
  664. template <>
  665. class Get<7> {
  666. public:
  667. template <class Tuple>
  668. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
  669. Field(Tuple& t) { return t.f7_; } // NOLINT
  670. template <class Tuple>
  671. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple))
  672. ConstField(const Tuple& t) { return t.f7_; }
  673. };
  674. template <>
  675. class Get<8> {
  676. public:
  677. template <class Tuple>
  678. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
  679. Field(Tuple& t) { return t.f8_; } // NOLINT
  680. template <class Tuple>
  681. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple))
  682. ConstField(const Tuple& t) { return t.f8_; }
  683. };
  684. template <>
  685. class Get<9> {
  686. public:
  687. template <class Tuple>
  688. static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
  689. Field(Tuple& t) { return t.f9_; } // NOLINT
  690. template <class Tuple>
  691. static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple))
  692. ConstField(const Tuple& t) { return t.f9_; }
  693. };
  694. } // namespace gtest_internal
  695. template <int k, GTEST_10_TYPENAMES_(T)>
  696. GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
  697. get(GTEST_10_TUPLE_(T)& t) {
  698. return gtest_internal::Get<k>::Field(t);
  699. }
  700. template <int k, GTEST_10_TYPENAMES_(T)>
  701. GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T)))
  702. get(const GTEST_10_TUPLE_(T)& t) {
  703. return gtest_internal::Get<k>::ConstField(t);
  704. }
  705. // 6.1.3.5 Relational operators
  706. // We only implement == and !=, as we don't have a need for the rest yet.
  707. namespace gtest_internal {
  708. // SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the
  709. // first k fields of t1 equals the first k fields of t2.
  710. // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if
  711. // k1 != k2.
  712. template <int kSize1, int kSize2>
  713. struct SameSizeTuplePrefixComparator;
  714. template <>
  715. struct SameSizeTuplePrefixComparator<0, 0> {
  716. template <class Tuple1, class Tuple2>
  717. static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) {
  718. return true;
  719. }
  720. };
  721. template <int k>
  722. struct SameSizeTuplePrefixComparator<k, k> {
  723. template <class Tuple1, class Tuple2>
  724. static bool Eq(const Tuple1& t1, const Tuple2& t2) {
  725. return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) &&
  726. ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2);
  727. }
  728. };
  729. } // namespace gtest_internal
  730. template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
  731. inline bool operator==(const GTEST_10_TUPLE_(T)& t,
  732. const GTEST_10_TUPLE_(U)& u) {
  733. return gtest_internal::SameSizeTuplePrefixComparator<
  734. tuple_size<GTEST_10_TUPLE_(T)>::value,
  735. tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u);
  736. }
  737. template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)>
  738. inline bool operator!=(const GTEST_10_TUPLE_(T)& t,
  739. const GTEST_10_TUPLE_(U)& u) { return !(t == u); }
  740. // 6.1.4 Pairs.
  741. // Unimplemented.
  742. } // namespace tr1
  743. } // namespace std
  744. #undef GTEST_0_TUPLE_
  745. #undef GTEST_1_TUPLE_
  746. #undef GTEST_2_TUPLE_
  747. #undef GTEST_3_TUPLE_
  748. #undef GTEST_4_TUPLE_
  749. #undef GTEST_5_TUPLE_
  750. #undef GTEST_6_TUPLE_
  751. #undef GTEST_7_TUPLE_
  752. #undef GTEST_8_TUPLE_
  753. #undef GTEST_9_TUPLE_
  754. #undef GTEST_10_TUPLE_
  755. #undef GTEST_0_TYPENAMES_
  756. #undef GTEST_1_TYPENAMES_
  757. #undef GTEST_2_TYPENAMES_
  758. #undef GTEST_3_TYPENAMES_
  759. #undef GTEST_4_TYPENAMES_
  760. #undef GTEST_5_TYPENAMES_
  761. #undef GTEST_6_TYPENAMES_
  762. #undef GTEST_7_TYPENAMES_
  763. #undef GTEST_8_TYPENAMES_
  764. #undef GTEST_9_TYPENAMES_
  765. #undef GTEST_10_TYPENAMES_
  766. #undef GTEST_DECLARE_TUPLE_AS_FRIEND_
  767. #undef GTEST_BY_REF_
  768. #undef GTEST_ADD_REF_
  769. #undef GTEST_TUPLE_ELEMENT_
  770. #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_