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 && v->push_back(v2_) != nullptr;
157  }
158 
159  private:
160  const T1 v1_;
161  const T2 v2_;
162  SelfType& operator=(const SelfType&);
163 };
164 
165 template<class T1, class T2, class T3>
166 class Values3 NLIB_FINAL {
167  typedef Values3 SelfType;
168 
169  public:
170  Values3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {}
171 
172  template<class T>
173  bool Gen(Nlist<T>* v) const {
174  return v->push_back(v1_) != nullptr && v->push_back(v2_) != nullptr &&
175  v->push_back(v3_) != nullptr;
176  }
177 
178  private:
179  const T1 v1_;
180  const T2 v2_;
181  const T3 v3_;
182  SelfType& operator=(const SelfType&);
183 };
184 
185 template<class T1, class T2, class T3, class T4>
186 class Values4 NLIB_FINAL {
187  typedef Values4 SelfType;
188 
189  public:
190  Values4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3), v4_(v4) {}
191 
192  template<class T>
193  bool Gen(Nlist<T>* v) const {
194  return v->push_back(v1_) != nullptr && v->push_back(v2_) != nullptr &&
195  v->push_back(v3_) != nullptr && v->push_back(v4_) != nullptr;
196  }
197 
198  private:
199  const T1 v1_;
200  const T2 v2_;
201  const T3 v3_;
202  const T4 v4_;
203  SelfType& operator=(const SelfType&);
204 };
205 
206 template<class T1, class T2, class T3, class T4, class T5>
207 class Values5 NLIB_FINAL {
208  typedef Values5 SelfType;
209 
210  public:
211  Values5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5) {}
212 
213  template<class T>
214  bool Gen(Nlist<T>* v) const {
215  return v->push_back(v1_) != nullptr && v->push_back(v2_) != nullptr &&
216  v->push_back(v3_) != nullptr && v->push_back(v4_) != nullptr &&
217  v->push_back(v5_) != nullptr;
218  }
219 
220  private:
221  const T1 v1_;
222  const T2 v2_;
223  const T3 v3_;
224  const T4 v4_;
225  const T5 v5_;
226  SelfType& operator=(const SelfType&);
227 };
228 
229 template<class T1, class T2, class T3, class T4, class T5, class T6>
230 class Values6 NLIB_FINAL {
231  typedef Values6 SelfType;
232 
233  public:
234  Values6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) :
235  v1_(v1),
236  v2_(v2),
237  v3_(v3),
238  v4_(v4),
239  v5_(v5),
240  v6_(v6) {}
241 
242  template<class T>
243  bool Gen(Nlist<T>* v) const {
244  return v->push_back(v1_) != nullptr && v->push_back(v2_) != nullptr &&
245  v->push_back(v3_) != nullptr && v->push_back(v4_) != nullptr &&
246  v->push_back(v5_) != nullptr && v->push_back(v6_) != nullptr;
247  }
248 
249  private:
250  const T1 v1_;
251  const T2 v2_;
252  const T3 v3_;
253  const T4 v4_;
254  const T5 v5_;
255  const T6 v6_;
256  SelfType& operator=(const SelfType&);
257 };
258 
259 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
260 class Values7 NLIB_FINAL {
261  typedef Values7 SelfType;
262 
263  public:
264  Values7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) :
265  v1_(v1),
266  v2_(v2),
267  v3_(v3),
268  v4_(v4),
269  v5_(v5),
270  v6_(v6),
271  v7_(v7) {}
272 
273  template<class T>
274  bool Gen(Nlist<T>* v) const {
275  return v->push_back(v1_) != nullptr && v->push_back(v2_) != nullptr &&
276  v->push_back(v3_) != nullptr && v->push_back(v4_) != nullptr &&
277  v->push_back(v5_) != nullptr && v->push_back(v6_) != nullptr &&
278  v->push_back(v7_) != nullptr;
279  }
280 
281  private:
282  const T1 v1_;
283  const T2 v2_;
284  const T3 v3_;
285  const T4 v4_;
286  const T5 v5_;
287  const T6 v6_;
288  const T7 v7_;
289  SelfType& operator=(const SelfType&);
290 };
291 
292 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
293 class Values8 NLIB_FINAL {
294  typedef Values8 SelfType;
295 
296  public:
297  Values8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) :
298  v1_(v1),
299  v2_(v2),
300  v3_(v3),
301  v4_(v4),
302  v5_(v5),
303  v6_(v6),
304  v7_(v7),
305  v8_(v8) {}
306 
307  template<class T>
308  bool Gen(Nlist<T>* v) const {
309  return v->push_back(v1_) != nullptr && v->push_back(v2_) != nullptr &&
310  v->push_back(v3_) != nullptr && v->push_back(v4_) != nullptr &&
311  v->push_back(v5_) != nullptr && v->push_back(v6_) != nullptr &&
312  v->push_back(v7_) != nullptr && v->push_back(v8_) != nullptr;
313  }
314 
315  private:
316  const T1 v1_;
317  const T2 v2_;
318  const T3 v3_;
319  const T4 v4_;
320  const T5 v5_;
321  const T6 v6_;
322  const T7 v7_;
323  const T8 v8_;
324  SelfType& operator=(const SelfType&);
325 };
326 
327 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
328 class Values9 NLIB_FINAL {
329  typedef Values9 SelfType;
330 
331  public:
332  Values9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) :
333  v1_(v1),
334  v2_(v2),
335  v3_(v3),
336  v4_(v4),
337  v5_(v5),
338  v6_(v6),
339  v7_(v7),
340  v8_(v8),
341  v9_(v9) {}
342 
343  template<class T>
344  bool Gen(Nlist<T>* v) const {
345  return v->push_back(v1_) != nullptr && v->push_back(v2_) != nullptr &&
346  v->push_back(v3_) != nullptr && v->push_back(v4_) != nullptr &&
347  v->push_back(v5_) != nullptr && v->push_back(v6_) != nullptr &&
348  v->push_back(v7_) != nullptr && v->push_back(v8_) != nullptr &&
349  v->push_back(v9_) != nullptr;
350  }
351 
352  private:
353  const T1 v1_;
354  const T2 v2_;
355  const T3 v3_;
356  const T4 v4_;
357  const T5 v5_;
358  const T6 v6_;
359  const T7 v7_;
360  const T8 v8_;
361  const T9 v9_;
362  SelfType& operator=(const SelfType&);
363 };
364 
365 template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9,
366  class T10>
367 class Values10 NLIB_FINAL {
368  typedef Values10 SelfType;
369 
370  public:
371  Values10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) :
372  v1_(v1),
373  v2_(v2),
374  v3_(v3),
375  v4_(v4),
376  v5_(v5),
377  v6_(v6),
378  v7_(v7),
379  v8_(v8),
380  v9_(v9),
381  v10_(v10) {}
382 
383  template<class T>
384  bool Gen(Nlist<T>* v) const {
385  return v->push_back(v1_) != nullptr && v->push_back(v2_) != nullptr &&
386  v->push_back(v3_) != nullptr && v->push_back(v4_) != nullptr &&
387  v->push_back(v5_) != nullptr && v->push_back(v6_) != nullptr &&
388  v->push_back(v7_) != nullptr && v->push_back(v8_) != nullptr &&
389  v->push_back(v9_) != nullptr && v->push_back(v10_) != nullptr;
390  }
391 
392  private:
393  const T1 v1_;
394  const T2 v2_;
395  const T3 v3_;
396  const T4 v4_;
397  const T5 v5_;
398  const T6 v6_;
399  const T7 v7_;
400  const T8 v8_;
401  const T9 v9_;
402  const T10 v10_;
403  SelfType& operator=(const SelfType&);
404 };
405 
406 } // namespace detail
407 } // namespace testing
408 NLIB_NAMESPACE_END
409 
410 #endif // INCLUDE_NN_NLIB_TESTING_PARAMVALUETYPES_H_
Defines that class that is corresponding to std::unique_ptr.
Defines the class that resembles std::vector but can store objects that cannot be copied...
A file that contains the configuration information for each development environment.
#define NLIB_FINAL
Defines final if it is available for use. If not, holds an empty string.
Definition: Config.h:250