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