← Back to branch summary

~raof/mir/symbols-file

« back to all changes in this revision

Viewing changes to 3rd_party/gmock/include/gmock/internal/gmock-generated-internal-utils.h

  • Committer: Tarmac
  • Author(s): Kevin DuBois
  • Date: 2013-07-12 06:12:08 UTC
  • mfrom: (835.4.12 rm-internal-gmock)
  • Revision ID: tarmac-20130712061208-axrnr0n8xgjgexhz
remove google mock from the internal source tree. Rather, use the google-mock package and build the source externally. Fixes: https://bugs.launchpad.net/bugs/1185265, https://bugs.launchpad.net/bugs/1194017.

Approved by Didier Roche, PS Jenkins bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
3rd_party/gmock/include/gmock/internal/gmock-generated-internal-utils.h
1
 
// This file was GENERATED by command:
2
 
//     pump.py gmock-generated-internal-utils.h.pump
3
 
// DO NOT EDIT BY HAND!!!
4
 
 
5
 
// Copyright 2007, Google Inc.
6
 
// All rights reserved.
7
 
//
8
 
// Redistribution and use in source and binary forms, with or without
9
 
// modification, are permitted provided that the following conditions are
10
 
// met:
11
 
//
12
 
//     * Redistributions of source code must retain the above copyright
13
 
// notice, this list of conditions and the following disclaimer.
14
 
//     * Redistributions in binary form must reproduce the above
15
 
// copyright notice, this list of conditions and the following disclaimer
16
 
// in the documentation and/or other materials provided with the
17
 
// distribution.
18
 
//     * Neither the name of Google Inc. nor the names of its
19
 
// contributors may be used to endorse or promote products derived from
20
 
// this software without specific prior written permission.
21
 
//
22
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23
 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24
 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25
 
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
26
 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
27
 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
28
 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
29
 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
30
 
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
31
 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
32
 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
 
//
34
 
// Author: wan@google.com (Zhanyong Wan)
35
 
 
36
 
// Google Mock - a framework for writing C++ mock classes.
37
 
//
38
 
// This file contains template meta-programming utility classes needed
39
 
// for implementing Google Mock.
40
 
 
41
 
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
42
 
#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_
43
 
 
44
 
#include "gmock/internal/gmock-port.h"
45
 
 
46
 
namespace testing {
47
 
 
48
 
template <typename T>
49
 
class Matcher;
50
 
 
51
 
namespace internal {
52
 
 
53
 
// An IgnoredValue object can be implicitly constructed from ANY value.
54
 
// This is used in implementing the IgnoreResult(a) action.
55
 
class IgnoredValue {
56
 
 public:
57
 
  // This constructor template allows any value to be implicitly
58
 
  // converted to IgnoredValue.  The object has no data member and
59
 
  // doesn't try to remember anything about the argument.  We
60
 
  // deliberately omit the 'explicit' keyword in order to allow the
61
 
  // conversion to be implicit.
62
 
  template <typename T>
63
 
  IgnoredValue(const T& /* ignored */) {}  // NOLINT(runtime/explicit)
64
 
};
65
 
 
66
 
// MatcherTuple<T>::type is a tuple type where each field is a Matcher
67
 
// for the corresponding field in tuple type T.
68
 
template <typename Tuple>
69
 
struct MatcherTuple;
70
 
 
71
 
template <>
72
 
struct MatcherTuple< ::std::tr1::tuple<> > {
73
 
  typedef ::std::tr1::tuple< > type;
74
 
};
75
 
 
76
 
template <typename A1>
77
 
struct MatcherTuple< ::std::tr1::tuple<A1> > {
78
 
  typedef ::std::tr1::tuple<Matcher<A1> > type;
79
 
};
80
 
 
81
 
template <typename A1, typename A2>
82
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2> > {
83
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2> > type;
84
 
};
85
 
 
86
 
template <typename A1, typename A2, typename A3>
87
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3> > {
88
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type;
89
 
};
90
 
 
91
 
template <typename A1, typename A2, typename A3, typename A4>
92
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4> > {
93
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
94
 
      Matcher<A4> > type;
95
 
};
96
 
 
97
 
template <typename A1, typename A2, typename A3, typename A4, typename A5>
98
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5> > {
99
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
100
 
      Matcher<A5> > type;
101
 
};
102
 
 
103
 
template <typename A1, typename A2, typename A3, typename A4, typename A5,
104
 
    typename A6>
105
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6> > {
106
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
107
 
      Matcher<A5>, Matcher<A6> > type;
108
 
};
109
 
 
110
 
template <typename A1, typename A2, typename A3, typename A4, typename A5,
111
 
    typename A6, typename A7>
112
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7> > {
113
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
114
 
      Matcher<A5>, Matcher<A6>, Matcher<A7> > type;
115
 
};
116
 
 
117
 
template <typename A1, typename A2, typename A3, typename A4, typename A5,
118
 
    typename A6, typename A7, typename A8>
119
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
120
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
121
 
      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8> > type;
122
 
};
123
 
 
124
 
template <typename A1, typename A2, typename A3, typename A4, typename A5,
125
 
    typename A6, typename A7, typename A8, typename A9>
126
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
127
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
128
 
      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9> > type;
129
 
};
130
 
 
131
 
template <typename A1, typename A2, typename A3, typename A4, typename A5,
132
 
    typename A6, typename A7, typename A8, typename A9, typename A10>
133
 
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
134
 
    A10> > {
135
 
  typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
136
 
      Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9>,
137
 
      Matcher<A10> > type;
138
 
};
139
 
 
140
 
// Template struct Function<F>, where F must be a function type, contains
141
 
// the following typedefs:
142
 
//
143
 
//   Result:               the function's return type.
144
 
//   ArgumentN:            the type of the N-th argument, where N starts with 1.
145
 
//   ArgumentTuple:        the tuple type consisting of all parameters of F.
146
 
//   ArgumentMatcherTuple: the tuple type consisting of Matchers for all
147
 
//                         parameters of F.
148
 
//   MakeResultVoid:       the function type obtained by substituting void
149
 
//                         for the return type of F.
150
 
//   MakeResultIgnoredValue:
151
 
//                         the function type obtained by substituting Something
152
 
//                         for the return type of F.
153
 
template <typename F>
154
 
struct Function;
155
 
 
156
 
template <typename R>
157
 
struct Function<R()> {
158
 
  typedef R Result;
159
 
  typedef ::std::tr1::tuple<> ArgumentTuple;
160
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
161
 
  typedef void MakeResultVoid();
162
 
  typedef IgnoredValue MakeResultIgnoredValue();
163
 
};
164
 
 
165
 
template <typename R, typename A1>
166
 
struct Function<R(A1)>
167
 
    : Function<R()> {
168
 
  typedef A1 Argument1;
169
 
  typedef ::std::tr1::tuple<A1> ArgumentTuple;
170
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
171
 
  typedef void MakeResultVoid(A1);
172
 
  typedef IgnoredValue MakeResultIgnoredValue(A1);
173
 
};
174
 
 
175
 
template <typename R, typename A1, typename A2>
176
 
struct Function<R(A1, A2)>
177
 
    : Function<R(A1)> {
178
 
  typedef A2 Argument2;
179
 
  typedef ::std::tr1::tuple<A1, A2> ArgumentTuple;
180
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
181
 
  typedef void MakeResultVoid(A1, A2);
182
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
183
 
};
184
 
 
185
 
template <typename R, typename A1, typename A2, typename A3>
186
 
struct Function<R(A1, A2, A3)>
187
 
    : Function<R(A1, A2)> {
188
 
  typedef A3 Argument3;
189
 
  typedef ::std::tr1::tuple<A1, A2, A3> ArgumentTuple;
190
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
191
 
  typedef void MakeResultVoid(A1, A2, A3);
192
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
193
 
};
194
 
 
195
 
template <typename R, typename A1, typename A2, typename A3, typename A4>
196
 
struct Function<R(A1, A2, A3, A4)>
197
 
    : Function<R(A1, A2, A3)> {
198
 
  typedef A4 Argument4;
199
 
  typedef ::std::tr1::tuple<A1, A2, A3, A4> ArgumentTuple;
200
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
201
 
  typedef void MakeResultVoid(A1, A2, A3, A4);
202
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
203
 
};
204
 
 
205
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
206
 
    typename A5>
207
 
struct Function<R(A1, A2, A3, A4, A5)>
208
 
    : Function<R(A1, A2, A3, A4)> {
209
 
  typedef A5 Argument5;
210
 
  typedef ::std::tr1::tuple<A1, A2, A3, A4, A5> ArgumentTuple;
211
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
212
 
  typedef void MakeResultVoid(A1, A2, A3, A4, A5);
213
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
214
 
};
215
 
 
216
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
217
 
    typename A5, typename A6>
218
 
struct Function<R(A1, A2, A3, A4, A5, A6)>
219
 
    : Function<R(A1, A2, A3, A4, A5)> {
220
 
  typedef A6 Argument6;
221
 
  typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple;
222
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
223
 
  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
224
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
225
 
};
226
 
 
227
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
228
 
    typename A5, typename A6, typename A7>
229
 
struct Function<R(A1, A2, A3, A4, A5, A6, A7)>
230
 
    : Function<R(A1, A2, A3, A4, A5, A6)> {
231
 
  typedef A7 Argument7;
232
 
  typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple;
233
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
234
 
  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
235
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
236
 
};
237
 
 
238
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
239
 
    typename A5, typename A6, typename A7, typename A8>
240
 
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)>
241
 
    : Function<R(A1, A2, A3, A4, A5, A6, A7)> {
242
 
  typedef A8 Argument8;
243
 
  typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple;
244
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
245
 
  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
246
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8);
247
 
};
248
 
 
249
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
250
 
    typename A5, typename A6, typename A7, typename A8, typename A9>
251
 
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
252
 
    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
253
 
  typedef A9 Argument9;
254
 
  typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> ArgumentTuple;
255
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
256
 
  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
257
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
258
 
      A9);
259
 
};
260
 
 
261
 
template <typename R, typename A1, typename A2, typename A3, typename A4,
262
 
    typename A5, typename A6, typename A7, typename A8, typename A9,
263
 
    typename A10>
264
 
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
265
 
    : Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
266
 
  typedef A10 Argument10;
267
 
  typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
268
 
      A10> ArgumentTuple;
269
 
  typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
270
 
  typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
271
 
  typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
272
 
      A9, A10);
273
 
};
274
 
 
275
 
}  // namespace internal
276
 
 
277
 
}  // namespace testing
278
 
 
279
 
#endif  // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_GENERATED_INTERNAL_UTILS_H_