nlib
ParamValueTypes.h
1 
2 #pragma once
3 #ifndef INCLUDE_NN_NLIB_TESTING_PARAMVALUETYPES_H_
4 #define INCLUDE_NN_NLIB_TESTING_PARAMVALUETYPES_H_
5 
6 #include <memory>
7 
8 #include "nn/nlib/Config.h"
9 #include "nn/nlib/UniquePtr.h"
10 #include "nn/nlib/Nlist.h"
11 
12 NLIB_NAMESPACE_BEGIN
13 namespace testing {
14 namespace detail {
15 
16 class ValuesBool NLIB_FINAL {
17  public:
18  template<class T>
19  bool Gen(Nlist<T>* v) const {
20  return v->push_back(false) && v->push_back(true);
21  }
22 
23  private:
24  ValuesBool& operator=(const ValuesBool&);
25 };
26 
27 template <class C, size_t N>
28 class ValuesInObjArray NLIB_FINAL {
29  public:
30  explicit ValuesInObjArray(const C (&a)[N]) : array_(a) {}
31 
32  template<class T>
33  bool Gen(Nlist<T>* v) const {
34  for (size_t i = 0; i < N; ++i) {
35  if (!v->push_back(array_[i])) return false;
36  }
37  return true;
38  }
39 
40  private:
41  const C (&array_)[N];
42  ValuesInObjArray& operator=(const ValuesInObjArray&);
43 };
44 
45 template <class C>
46 class ValuesInObjContainer NLIB_FINAL {
47  public:
48  explicit ValuesInObjContainer(const C& c) : container_(&c) {}
49 
50  template<class T>
51  bool Gen(Nlist<T>* v) const {
52  typename C::const_iterator it = container_->begin();
53  typename C::const_iterator end = container_->end();
54  for (; it != end; ++it) {
55  if (!v->push_back(*it)) return false;
56  }
57  return true;
58  }
59 
60  private:
61  const C* container_;
62  ValuesInObjContainer& operator=(const ValuesInObjContainer&);
63 };
64 
65 template <class Iterator>
66 class ValuesInObjIterator NLIB_FINAL {
67  public:
68  ValuesInObjIterator(Iterator first, Iterator last) : first_(first), last_(last) {}
69 
70  template<class T>
71  bool Gen(Nlist<T>* v) const {
72  Iterator it = first_;
73  for (; it != last_; ++it) {
74  if (!v->push_back(*it)) return false;
75  }
76  return true;
77  }
78 
79  private:
80  Iterator first_;
81  Iterator last_;
82  ValuesInObjIterator& operator=(const ValuesInObjIterator&);
83 };
84 
85 template <class T1, class T2>
86 class ValuesRange NLIB_FINAL {
87  public:
88  ValuesRange(T1 first, T1 last, T2 step) : first_(first), last_(last), step_(step) {}
89 
90  template<class T>
91  bool Gen(Nlist<T>* v) const;
92 
93  private:
94  T1 first_;
95  T1 last_;
96  T2 step_;
97  ValuesRange& operator=(const ValuesRange&);
98 };
99 
100 template <class T1, class T2>
101 template <class T>
102 bool ValuesRange<T1, T2>::Gen(Nlist<T>* v) const {
103  // T must have:
104  // - default constructor
105  // - copy constructor
106  // - operator+, operator<
107  T first(first_);
108  T last(last_);
109  T2 step(step_);
110  while (first < last) {
111  if (!v->push_back(first)) return false;
112  first = first + step;
113  }
114  return true;
115 }
116 
117 template <class T1>
118 class Values1 NLIB_FINAL {
119  typedef Values1 SelfType;
120 
121  public:
122  explicit Values1(T1 v1) : v1_(v1) {}
123 
124  template<class T>
125  bool Gen(Nlist<T>* v) const {
126  return v->push_back(v1_) != NULL;
127  }
128 
129  private:
130  const T1 v1_;
131  SelfType& operator=(const SelfType&);
132 };
133 
134 template <class T1, class T2>
135 class Values2 NLIB_FINAL {
136  typedef Values2 SelfType;
137 
138  public:
139  Values2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {}
140 
141  template<class T>
142  bool Gen(Nlist<T>* v) const {
143  return v->push_back(v1_) != NULL &&
144  v->push_back(v2_) != NULL;
145  }
146 
147  private:
148  const T1 v1_;
149  const T2 v2_;
150  SelfType& operator=(const SelfType&);
151 };
152 
153 template <class T1, class T2, class T3>
154 class Values3 NLIB_FINAL {
155  typedef Values3 SelfType;
156 
157  public:
158  Values3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
159 
160  template<class T>
161  bool Gen(Nlist<T>* v) const {
162  return v->push_back(v1_) != NULL &&
163  v->push_back(v2_) != NULL &&
164  v->push_back(v3_) != NULL;
165  }
166 
167  private:
168  const T1 v1_;
169  const T2 v2_;
170  const T3 v3_;
171  SelfType& operator=(const SelfType&);
172 };
173 
174 template <class T1, class T2, class T3, class T4>
175 class Values4 NLIB_FINAL {
176  typedef Values4 SelfType;
177 
178  public:
179  Values4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3), v4_(v4) {}
180 
181  template<class T>
182  bool Gen(Nlist<T>* v) const {
183  return v->push_back(v1_) != NULL &&
184  v->push_back(v2_) != NULL &&
185  v->push_back(v3_) != NULL &&
186  v->push_back(v4_) != NULL;
187  }
188 
189  private:
190  const T1 v1_;
191  const T2 v2_;
192  const T3 v3_;
193  const T4 v4_;
194  SelfType& operator=(const SelfType&);
195 };
196 
197 template <class T1, class T2, class T3, class T4, class T5>
198 class Values5 NLIB_FINAL {
199  typedef Values5 SelfType;
200 
201  public:
202  Values5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5) {}
203 
204  template<class T>
205  bool Gen(Nlist<T>* v) const {
206  return v->push_back(v1_) != NULL &&
207  v->push_back(v2_) != NULL &&
208  v->push_back(v3_) != NULL &&
209  v->push_back(v4_) != NULL &&
210  v->push_back(v5_) != NULL;
211  }
212 
213  private:
214  const T1 v1_;
215  const T2 v2_;
216  const T3 v3_;
217  const T4 v4_;
218  const T5 v5_;
219  SelfType& operator=(const SelfType&);
220 };
221 
222 template <class T1, class T2, class T3, class T4, class T5, class T6>
223 class Values6 NLIB_FINAL {
224  typedef Values6 SelfType;
225 
226  public:
227  Values6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6)
228  : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6) {}
229 
230  template<class T>
231  bool Gen(Nlist<T>* v) const {
232  return v->push_back(v1_) != NULL &&
233  v->push_back(v2_) != NULL &&
234  v->push_back(v3_) != NULL &&
235  v->push_back(v4_) != NULL &&
236  v->push_back(v5_) != NULL &&
237  v->push_back(v6_) != NULL;
238  }
239 
240  private:
241  const T1 v1_;
242  const T2 v2_;
243  const T3 v3_;
244  const T4 v4_;
245  const T5 v5_;
246  const T6 v6_;
247  SelfType& operator=(const SelfType&);
248 };
249 
250 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
251 class Values7 NLIB_FINAL {
252  typedef Values7 SelfType;
253 
254  public:
255  Values7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7)
256  : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {}
257 
258  template<class T>
259  bool Gen(Nlist<T>* v) const {
260  return v->push_back(v1_) != NULL &&
261  v->push_back(v2_) != NULL &&
262  v->push_back(v3_) != NULL &&
263  v->push_back(v4_) != NULL &&
264  v->push_back(v5_) != NULL &&
265  v->push_back(v6_) != NULL &&
266  v->push_back(v7_) != NULL;
267  }
268 
269  private:
270  const T1 v1_;
271  const T2 v2_;
272  const T3 v3_;
273  const T4 v4_;
274  const T5 v5_;
275  const T6 v6_;
276  const T7 v7_;
277  SelfType& operator=(const SelfType&);
278 };
279 
280 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
281 class Values8 NLIB_FINAL {
282  typedef Values8 SelfType;
283 
284  public:
285  Values8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8)
286  : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8) {}
287 
288  template<class T>
289  bool Gen(Nlist<T>* v) const {
290  return v->push_back(v1_) != NULL &&
291  v->push_back(v2_) != NULL &&
292  v->push_back(v3_) != NULL &&
293  v->push_back(v4_) != NULL &&
294  v->push_back(v5_) != NULL &&
295  v->push_back(v6_) != NULL &&
296  v->push_back(v7_) != NULL &&
297  v->push_back(v8_) != NULL;
298  }
299 
300  private:
301  const T1 v1_;
302  const T2 v2_;
303  const T3 v3_;
304  const T4 v4_;
305  const T5 v5_;
306  const T6 v6_;
307  const T7 v7_;
308  const T8 v8_;
309  SelfType& operator=(const SelfType&);
310 };
311 
312 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
313 class Values9 NLIB_FINAL {
314  typedef Values9 SelfType;
315 
316  public:
317  Values9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9)
318  : v1_(v1),
319  v2_(v2),
320  v3_(v3),
321  v4_(v4),
322  v5_(v5),
323  v6_(v6),
324  v7_(v7),
325  v8_(v8),
326  v9_(v9) {}
327 
328  template<class T>
329  bool Gen(Nlist<T>* v) const {
330  return v->push_back(v1_) != NULL &&
331  v->push_back(v2_) != NULL &&
332  v->push_back(v3_) != NULL &&
333  v->push_back(v4_) != NULL &&
334  v->push_back(v5_) != NULL &&
335  v->push_back(v6_) != NULL &&
336  v->push_back(v7_) != NULL &&
337  v->push_back(v8_) != NULL &&
338  v->push_back(v9_) != NULL;
339  }
340 
341  private:
342  const T1 v1_;
343  const T2 v2_;
344  const T3 v3_;
345  const T4 v4_;
346  const T5 v5_;
347  const T6 v6_;
348  const T7 v7_;
349  const T8 v8_;
350  const T9 v9_;
351  SelfType& operator=(const SelfType&);
352 };
353 
354 template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9,
355  class T10> // NOLINT
356 class Values10 NLIB_FINAL {
357  typedef Values10 SelfType;
358 
359  public:
360  Values10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10)
361  : v1_(v1),
362  v2_(v2),
363  v3_(v3),
364  v4_(v4),
365  v5_(v5),
366  v6_(v6),
367  v7_(v7),
368  v8_(v8),
369  v9_(v9),
370  v10_(v10) {}
371 
372  template<class T>
373  bool Gen(Nlist<T>* v) const {
374  return v->push_back(v1_) != NULL &&
375  v->push_back(v2_) != NULL &&
376  v->push_back(v3_) != NULL &&
377  v->push_back(v4_) != NULL &&
378  v->push_back(v5_) != NULL &&
379  v->push_back(v6_) != NULL &&
380  v->push_back(v7_) != NULL &&
381  v->push_back(v8_) != NULL &&
382  v->push_back(v9_) != NULL &&
383  v->push_back(v10_) != NULL;
384  }
385 
386  private:
387  const T1 v1_;
388  const T2 v2_;
389  const T3 v3_;
390  const T4 v4_;
391  const T5 v5_;
392  const T6 v6_;
393  const T7 v7_;
394  const T8 v8_;
395  const T9 v9_;
396  const T10 v10_;
397  SelfType& operator=(const SelfType&);
398 };
399 
400 } // namespace detail
401 } // namespace testing
402 NLIB_NAMESPACE_END
403 
404 #endif // INCLUDE_NN_NLIB_TESTING_PARAMVALUETYPES_H_
std::unique_ptrに相当するクラスが定義されています。
std::vectorに似ていますが、コピーできないオブジェクトを格納可能なクラスが定義されています。 ...
開発環境別の設定が書かれるファイルです。
#define NLIB_FINAL
利用可能であればfinalが定義されます。そうでない場合は空文字列です。
Definition: Config.h:211