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