rttr  0.9.0
 All Classes Namespaces Files Functions Variables Typedefs Friends Macros Pages
array_container.h
Go to the documentation of this file.
1 /************************************************************************************
2 * *
3 * Copyright (c) 2014 Axel Menzel <info@axelmenzel.de> *
4 * *
5 * This file is part of RTTR (Run Time Type Reflection) *
6 * License: MIT License *
7 * *
8 * Permission is hereby granted, free of charge, to any person obtaining *
9 * a copy of this software and associated documentation files (the "Software"), *
10 * to deal in the Software without restriction, including without limitation *
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
12 * and/or sell copies of the Software, and to permit persons to whom the *
13 * Software is furnished to do so, subject to the following conditions: *
14 * *
15 * The above copyright notice and this permission notice shall be included in *
16 * all copies or substantial portions of the Software. *
17 * *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE *
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, *
23 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE *
24 * SOFTWARE. *
25 * *
26 *************************************************************************************/
27 
28 #ifndef __RTTR_ARRAY_CONTAINER_H__
29 #define __RTTR_ARRAY_CONTAINER_H__
30 
31 #include "rttr/base/core_prerequisites.h"
32 #include "rttr/detail/array_container_base.h"
33 #include "rttr/detail/utility.h"
34 #include "rttr/detail/array_accessor.h"
35 #include "rttr/detail/array_mapper.h"
36 
37 #include <type_traits>
38 #include <cstddef>
39 
40 namespace rttr
41 {
42 
43 namespace detail
44 {
45 class argument;
46 template<typename T, typename Enable = void>
47 class array_container : public array_container_base
48 {
49  using ArrayType = typename detail::raw_type<T>::type;
50  public:
51  array_container(const T& arg)
52  : _value(arg)
53  {
54 
55  }
56 
57  array_container(T&& arg)
58  : _value(std::move(arg))
59  {
60 
61  }
62 
64 
65  bool is_dynamic() const { return array_mapper<ArrayType>::is_dynamic(); }
66  std::size_t get_rank() const { return rank<ArrayType>::value; }
67  type get_rank_type(std::size_t index) const { return array_accessor<ArrayType>::get_ranke_type(index); }
68  type get_type() const { return type::get<T>(); }
69  bool is_raw_array() const { return std::is_array<ArrayType>::value; }
70 
72 
73  std::size_t get_size() const
74  {
75  return array_accessor<ArrayType>::get_size(_value);
76  }
77  std::size_t get_size(std::size_t index_1) const
78  {
79  return array_accessor<ArrayType>::get_size(_value, index_1);
80  }
81  std::size_t get_size(std::size_t index_1, std::size_t index_2) const
82  {
83  return array_accessor<ArrayType>::get_size(_value, index_1, index_2);
84  }
85  std::size_t get_size_variadic(const std::vector<std::size_t>& index_list) const
86  {
87  return array_accessor<ArrayType>::get_size(_value, index_list);
88  }
89 
91 
92  bool set_size(std::size_t new_size)
93  {
94  return array_accessor<ArrayType>::set_size(_value, new_size);
95  }
96  bool set_size(std::size_t new_size, std::size_t index_1)
97  {
98  return array_accessor<ArrayType>::set_size(_value, new_size, index_1);
99  }
100  bool set_size(std::size_t new_size, std::size_t index_1, std::size_t index_2)
101  {
102  return array_accessor<ArrayType>::set_size(_value, new_size, index_1, index_2);
103  }
104  bool set_size_variadic(std::size_t new_size, const std::vector<std::size_t>& index_list)
105  {
106  return array_accessor<ArrayType>::set_size(_value, new_size, index_list);
107  }
108 
110 
111  bool set_value(argument& arg)
112  {
113  return array_accessor<ArrayType>::set_value(_value, arg);
114  }
115 
116  bool set_value(argument& arg, std::size_t index_1)
117  {
118  return array_accessor<ArrayType>::set_value(_value, arg, index_1);
119  }
120  bool set_value(argument& arg, std::size_t index_1, std::size_t index_2)
121  {
122  return array_accessor<ArrayType>::set_value(_value, arg, index_1, index_2);
123  }
124 
125  bool set_value(argument& arg, std::size_t index_1, std::size_t index_2, std::size_t index_3)
126  {
127  return array_accessor<ArrayType>::set_value(_value, arg, index_1, index_2, index_3);
128  }
129 
130  bool set_value_variadic(argument& arg, const std::vector<std::size_t>& index_list)
131  {
132  return array_accessor<ArrayType>::set_value(_value, arg, index_list);
133  }
134 
136 
137  variant get_value(std::size_t index_1) const
138  {
139  return array_accessor<ArrayType>::get_value(_value, index_1);
140  }
141 
142  variant get_value(std::size_t index_1, std::size_t index_2) const
143  {
144  return array_accessor<ArrayType>::get_value(_value, index_1, index_2);
145  }
146 
147  variant get_value(std::size_t index_1, std::size_t index_2, std::size_t index_3) const
148  {
149  return array_accessor<ArrayType>::get_value(_value, index_1, index_2, index_3);
150  }
151 
152  variant get_value_variadic(const std::vector<std::size_t>& index_list) const
153  {
154  return array_accessor<ArrayType>::get_value(_value, index_list);
155  }
156 
158 
159  bool insert_value(detail::argument& arg, std::size_t index_1)
160  {
161  return array_accessor<ArrayType>::insert_value(_value, arg, index_1);
162  }
163 
164  bool insert_value(detail::argument& arg, std::size_t index_1, std::size_t index_2)
165  {
166  return array_accessor<ArrayType>::insert_value(_value, arg, index_1, index_2);
167  }
168 
169  bool insert_value(detail::argument& arg, std::size_t index_1, std::size_t index_2, std::size_t index_3)
170  {
171  return array_accessor<ArrayType>::insert_value(_value, arg, index_1, index_2, index_3);
172  }
173 
174  bool insert_value_variadic(detail::argument& arg, const std::vector<std::size_t>& index_list)
175  {
176  return array_accessor<ArrayType>::insert_value(_value, arg, index_list);
177  }
178 
180 
181  bool remove_value(std::size_t index_1)
182  {
183  return array_accessor<ArrayType>::remove_value(_value, index_1);
184  }
185 
186  bool remove_value(std::size_t index_1, std::size_t index_2)
187  {
188  return array_accessor<ArrayType>::remove_value(_value, index_1, index_2);
189  }
190 
191  bool remove_value(std::size_t index_1, std::size_t index_2, std::size_t index_3)
192  {
193  return array_accessor<ArrayType>::remove_value(_value, index_1, index_2, index_3);
194  }
195  bool remove_value_variadic(const std::vector<std::size_t>& index_list)
196  {
197  return array_accessor<ArrayType>::remove_value(_value, index_list);
198  }
199 
200  array_container_base* clone() const { return new array_container<T>(_value); }
201 
202  void* get_ptr() const { return const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_value))); }
203 
204  private:
205  T _value;
206 };
207 
211 // T*
212 
213 template<typename T>
214 class array_container<T*> : public array_container_base
215 {
216  using ArrayType = typename detail::raw_type<T>::type;
217  public:
218  array_container(T* arg)
219  : _value(static_cast<ArrayType*>(get_void_ptr(arg)))
220  {
221  }
222 
224 
225  bool is_dynamic() const { return array_mapper<ArrayType>::is_dynamic(); }
226  std::size_t get_rank() const { return rank<ArrayType>::value; }
227  type get_rank_type(std::size_t index) const { return array_accessor<ArrayType>::get_ranke_type(index); }
228  type get_type() const { return type::get<T*>(); }
229  bool is_raw_array() const { return std::is_array<ArrayType>::value; }
230 
232 
233  std::size_t get_size() const
234  {
235  return array_accessor<ArrayType>::get_size(*_value);
236  }
237  std::size_t get_size(std::size_t index_1) const
238  {
239  return array_accessor<ArrayType>::get_size(*_value, index_1);
240  }
241  std::size_t get_size(std::size_t index_1, std::size_t index_2) const
242  {
243  return array_accessor<ArrayType>::get_size(*_value, index_1, index_2);
244  }
245  std::size_t get_size_variadic(const std::vector<std::size_t>& index_list) const
246  {
247  return array_accessor<ArrayType>::get_size(*_value, index_list);
248  }
249 
251 
252  bool set_size(std::size_t new_size)
253  {
254  return array_accessor<ArrayType>::set_size(*_value, new_size);
255  }
256  bool set_size(std::size_t new_size, std::size_t index_1)
257  {
258  return array_accessor<ArrayType>::set_size(*_value, new_size, index_1);
259  }
260  bool set_size(std::size_t new_size, std::size_t index_1, std::size_t index_2)
261  {
262  return array_accessor<ArrayType>::set_size(*_value, new_size, index_1, index_2);
263  }
264  bool set_size_variadic(std::size_t new_size, const std::vector<std::size_t>& index_list)
265  {
266  return array_accessor<ArrayType>::set_size(*_value, new_size, index_list);
267  }
268 
270 
271  bool set_value(argument& arg)
272  {
273  return array_accessor<ArrayType>::set_value(*_value, arg);
274  }
275 
276  bool set_value(argument& arg, std::size_t index_1)
277  {
278  return array_accessor<ArrayType>::set_value(*_value, arg, index_1);
279  }
280  bool set_value(argument& arg, std::size_t index_1, std::size_t index_2)
281  {
282  return array_accessor<ArrayType>::set_value(*_value, arg, index_1, index_2);
283  }
284 
285  bool set_value(argument& arg, std::size_t index_1, std::size_t index_2, std::size_t index_3)
286  {
287  return array_accessor<ArrayType>::set_value(*_value, arg, index_1, index_2, index_3);
288  }
289 
290  bool set_value_variadic(argument& arg, const std::vector<std::size_t>& index_list)
291  {
292  return array_accessor<ArrayType>::set_value(*_value, arg, index_list);
293  }
294 
296 
297  variant get_value(std::size_t index_1) const
298  {
299  return array_accessor<ArrayType>::get_value(*_value, index_1);
300  }
301 
302  variant get_value(std::size_t index_1, std::size_t index_2) const
303  {
304  return array_accessor<ArrayType>::get_value(*_value, index_1, index_2);
305  }
306 
307  variant get_value(std::size_t index_1, std::size_t index_2, std::size_t index_3) const
308  {
309  return array_accessor<ArrayType>::get_value(*_value, index_1, index_2, index_3);
310  }
311 
312  variant get_value_variadic(const std::vector<std::size_t>& index_list) const
313  {
314  return array_accessor<ArrayType>::get_value(*_value, index_list);
315  }
316 
318 
319  bool insert_value(detail::argument& arg, std::size_t index_1)
320  {
321  return array_accessor<ArrayType>::insert_value(*_value, arg, index_1);
322  }
323 
324  bool insert_value(detail::argument& arg, std::size_t index_1, std::size_t index_2)
325  {
326  return array_accessor<ArrayType>::insert_value(*_value, arg, index_1, index_2);
327  }
328 
329  bool insert_value(detail::argument& arg, std::size_t index_1, std::size_t index_2, std::size_t index_3)
330  {
331  return array_accessor<ArrayType>::insert_value(*_value, arg, index_1, index_2, index_3);
332  }
333 
334  bool insert_value_variadic(detail::argument& arg, const std::vector<std::size_t>& index_list)
335  {
336  return array_accessor<ArrayType>::insert_value(*_value, arg, index_list);
337  }
338 
340 
341  bool remove_value(std::size_t index_1)
342  {
343  return array_accessor<ArrayType>::remove_value(*_value, index_1);
344  }
345 
346  bool remove_value(std::size_t index_1, std::size_t index_2)
347  {
348  return array_accessor<ArrayType>::remove_value(*_value, index_1, index_2);
349  }
350 
351  bool remove_value(std::size_t index_1, std::size_t index_2, std::size_t index_3)
352  {
353  return array_accessor<ArrayType>::remove_value(*_value, index_1, index_2, index_3);
354  }
355  bool remove_value_variadic(const std::vector<std::size_t>& index_list)
356  {
357  return array_accessor<ArrayType>::remove_value(*_value, index_list);
358  }
359 
360  array_container_base* clone() const { return new array_container<ArrayType*>(_value); }
361 
362  void* get_ptr() const { return const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_value))); }
363 
364  private:
365  ArrayType* _value;
366 };
367 
371 // const T*
372 
373 template<typename T>
374 class array_container<const T*> : public array_container_base
375 {
376  using ArrayType = typename detail::raw_type<T>::type;
377  public:
378  array_container(const T* arg)
379  : _value(static_cast<const T*>(get_void_ptr(arg)))
380  {
381  }
382 
384 
385  bool is_dynamic() const { return array_mapper<ArrayType>::is_dynamic(); }
386  std::size_t get_rank() const { return rank<ArrayType>::value; }
387  type get_rank_type(std::size_t index) const { return array_accessor<ArrayType>::get_ranke_type(index); }
388  type get_type() const { return type::get<const T*>(); }
389  bool is_raw_array() const { return std::is_array<ArrayType>::value; }
390 
392 
393  std::size_t get_size() const
394  {
395  return array_accessor<ArrayType>::get_size(*_value);
396  }
397  std::size_t get_size(std::size_t index_1) const
398  {
399  return array_accessor<ArrayType>::get_size(*_value, index_1);
400  }
401  std::size_t get_size(std::size_t index_1, std::size_t index_2) const
402  {
403  return array_accessor<ArrayType>::get_size(*_value, index_1, index_2);
404  }
405  std::size_t get_size_variadic(const std::vector<std::size_t>& index_list) const
406  {
407  return array_accessor<ArrayType>::get_size(*_value, index_list);
408  }
409 
411 
412  bool set_size(std::size_t new_size)
413  {
414  return false;
415  }
416  bool set_size(std::size_t new_size, std::size_t index_1)
417  {
418  return false;
419  }
420  bool set_size(std::size_t new_size, std::size_t index_1, std::size_t index_2)
421  {
422  return false;
423  }
424  bool set_size_variadic(std::size_t new_size, const std::vector<std::size_t>& index_list)
425  {
426  return false;
427  }
428 
430 
431  bool set_value(argument& arg)
432  {
433  return false;
434  }
435 
436  bool set_value(argument& arg, std::size_t index_1)
437  {
438  return false;
439  }
440  bool set_value(argument& arg, std::size_t index_1, std::size_t index_2)
441  {
442  return false;
443  }
444 
445  bool set_value(argument& arg, std::size_t index_1, std::size_t index_2, std::size_t index_3)
446  {
447  return false;
448  }
449 
450  bool set_value_variadic(argument& arg, const std::vector<std::size_t>& index_list)
451  {
452  return false;
453  }
454 
456 
457  variant get_value(std::size_t index_1) const
458  {
459  return array_accessor<ArrayType>::get_value(*_value, index_1);
460  }
461 
462  variant get_value(std::size_t index_1, std::size_t index_2) const
463  {
464  return array_accessor<ArrayType>::get_value(*_value, index_1, index_2);
465  }
466 
467  variant get_value(std::size_t index_1, std::size_t index_2, std::size_t index_3) const
468  {
469  return array_accessor<ArrayType>::get_value(*_value, index_1, index_2, index_3);
470  }
471 
472  variant get_value_variadic(const std::vector<std::size_t>& index_list) const
473  {
474  return array_accessor<ArrayType>::get_value(*_value, index_list);
475  }
476 
478 
479  bool insert_value(detail::argument& arg, std::size_t index_1)
480  {
481  return false;
482  }
483 
484  bool insert_value(detail::argument& arg, std::size_t index_1, std::size_t index_2)
485  {
486  return false;
487  }
488 
489  bool insert_value(detail::argument& arg, std::size_t index_1, std::size_t index_2, std::size_t index_3)
490  {
491  return false;
492  }
493 
494  bool insert_value_variadic(detail::argument& arg, const std::vector<std::size_t>& index_list)
495  {
496  return false;
497  }
498 
500 
501  bool remove_value(std::size_t index_1)
502  {
503  return false;
504  }
505 
506  bool remove_value(std::size_t index_1, std::size_t index_2)
507  {
508  return false;
509  }
510 
511  bool remove_value(std::size_t index_1, std::size_t index_2, std::size_t index_3)
512  {
513  return false;
514  }
515  bool remove_value_variadic(const std::vector<std::size_t>& index_list)
516  {
517  return false;
518  }
519 
520  array_container_base* clone() const { return new array_container<const T*>(_value); }
521  void* get_ptr() const { return const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_value))); }
522 
523  private:
524  const T* _value;
525 };
526 
530 
531 template<typename T>
532 class array_container<T, typename std::enable_if<std::is_array<T>::value>::type> : public array_container_base
533 {
534  using ArrayType = typename detail::raw_type<T>::type;
535  public:
536  array_container(const T& arg)
537  {
538  #if RTTR_COMPILER == RTTR_COMPILER_MSVC
539  detail::copy_array(const_cast<std::remove_const<T>::type&>(arg), _value);
540  #else
541  detail::copy_array(arg, _value);
542  #endif
543  }
544 
546 
547  bool is_dynamic() const { return array_mapper<T>::is_dynamic(); }
548  std::size_t get_rank() const { return rank<T>::value; }
549  type get_rank_type(std::size_t index) const { return array_accessor<T>::get_ranke_type(index); }
550  type get_type() const { return type::get<T>(); }
551  bool is_raw_array() const { return std::is_array<T>::value; }
552 
554 
555  std::size_t get_size() const
556  {
557  return array_accessor<T>::get_size(_value);
558  }
559  std::size_t get_size(std::size_t index_1) const
560  {
561  return array_accessor<T>::get_size(_value, index_1);
562  }
563  std::size_t get_size(std::size_t index_1, std::size_t index_2) const
564  {
565  return array_accessor<T>::get_size(_value, index_1, index_2);
566  }
567  std::size_t get_size_variadic(const std::vector<std::size_t>& index_list) const
568  {
569  return array_accessor<T>::get_size(_value, index_list);
570  }
571 
573 
574  bool set_size(std::size_t new_size)
575  {
576  return array_accessor<T>::set_size(_value, new_size);
577  }
578  bool set_size(std::size_t new_size, std::size_t index_1)
579  {
580  return array_accessor<T>::set_size(_value, new_size, index_1);
581  }
582  bool set_size(std::size_t new_size, std::size_t index_1, std::size_t index_2)
583  {
584  return array_accessor<T>::set_size(_value, new_size, index_1, index_2);
585  }
586  bool set_size_variadic(std::size_t new_size, const std::vector<std::size_t>& index_list)
587  {
588  return array_accessor<T>::set_size(_value, new_size, index_list);
589  }
590 
592 
593  bool set_value(argument& arg)
594  {
595  return array_accessor<T>::set_value(_value, arg);
596  }
597 
598  bool set_value(argument& arg, std::size_t index_1)
599  {
600  return array_accessor<T>::set_value(_value, arg, index_1);
601  }
602  bool set_value(argument& arg, std::size_t index_1, std::size_t index_2)
603  {
604  return array_accessor<T>::set_value(_value, arg, index_1, index_2);
605  }
606 
607  bool set_value(argument& arg, std::size_t index_1, std::size_t index_2, std::size_t index_3)
608  {
609  return array_accessor<T>::set_value(_value, arg, index_1, index_2, index_3);
610  }
611 
612  bool set_value_variadic(argument& arg, const std::vector<std::size_t>& index_list)
613  {
614  return array_accessor<T>::set_value(_value, arg, index_list);
615  }
616 
618 
619  variant get_value(std::size_t index_1) const
620  {
621  return array_accessor<T>::get_value(_value, index_1);
622  }
623 
624  variant get_value(std::size_t index_1, std::size_t index_2) const
625  {
626  return array_accessor<T>::get_value(_value, index_1, index_2);
627  }
628 
629  variant get_value(std::size_t index_1, std::size_t index_2, std::size_t index_3) const
630  {
631  return array_accessor<T>::get_value(_value, index_1, index_2, index_3);
632  }
633 
634  variant get_value_variadic(const std::vector<std::size_t>& index_list) const
635  {
636  return array_accessor<T>::get_value(_value, index_list);
637  }
638 
640 
641  bool insert_value(detail::argument& arg, std::size_t index_1)
642  {
643  return array_accessor<T>::insert_value(_value, arg, index_1);
644  }
645 
646  bool insert_value(detail::argument& arg, std::size_t index_1, std::size_t index_2)
647  {
648  return array_accessor<T>::insert_value(_value, arg, index_1, index_2);
649  }
650 
651  bool insert_value(detail::argument& arg, std::size_t index_1, std::size_t index_2, std::size_t index_3)
652  {
653  return array_accessor<T>::insert_value(_value, arg, index_1, index_2, index_3);
654  }
655 
656  bool insert_value_variadic(detail::argument& arg, const std::vector<std::size_t>& index_list)
657  {
658  return array_accessor<T>::insert_value(_value, arg, index_list);
659  }
660 
662 
663  bool remove_value(std::size_t index_1)
664  {
665  return array_accessor<T>::remove_value(_value, index_1);
666  }
667 
668  bool remove_value(std::size_t index_1, std::size_t index_2)
669  {
670  return array_accessor<T>::remove_value(_value, index_1, index_2);
671  }
672 
673  bool remove_value(std::size_t index_1, std::size_t index_2, std::size_t index_3)
674  {
675  return array_accessor<T>::remove_value(_value, index_1, index_2, index_3);
676  }
677  bool remove_value_variadic(const std::vector<std::size_t>& index_list)
678  {
679  return array_accessor<T>::remove_value(_value, index_list);
680  }
681 
682  array_container_base* clone() const { return new array_container<T>(_value); }
683  void* get_ptr() const { return const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_value))); }
684 
685  private:
686  T _value;
688 };
689 
690 template<typename T, typename F>
691 array_container_base* create_array_container_impl(const F& value, typename std::enable_if<is_array<T>::value>::type* = 0)
692 {
693  using ArrayType = typename std::remove_cv<typename std::remove_reference<F>::type>::type;
694  return new array_container<ArrayType>(value);
695 }
696 
697 template<typename T, typename F>
698 array_container_base* create_array_container_impl(const F& value, typename std::enable_if<!is_array<T>::value>::type* = 0)
699 {
700  return nullptr;
701 }
702 
703 template<typename T, typename F>
704 array_container_base* create_array_container_moved_impl(F&& value, typename std::enable_if<is_array<T>::value>::type* = 0)
705 {
706  using ArrayType = typename std::remove_cv<typename std::remove_reference<F>::type>::type;
707  return new array_container<ArrayType>(std::move(value));
708 }
709 
710 template<typename T, typename F>
711 array_container_base* create_array_container_moved_impl(F&& value, typename std::enable_if<!is_array<T>::value>::type* = 0)
712 {
713  return nullptr;
714 }
715 
716 template<typename T>
717 array_container_base* create_array_container(const T& value)
718 {
719  return create_array_container_impl<typename detail::raw_type<T>::type, T>(value);
720 }
721 
722 template<typename T>
723 array_container_base* create_array_container_moved(T&& value)
724 {
725  return create_array_container_moved_impl<typename detail::raw_type<T>::type, T>(std::move(value));
726 }
727 
728 } // end namespace detail
729 } // end namespace rttr
730 
731 #endif // __RTTR_ARRAY_CONTAINER_H__
array_accessor.h
core_prerequisites.h
array_mapper.h
array_container_base.h
Generated on Sun Jul 13 2014 19:19:14 for rttr by   doxygen 1.8.7