hmbdc
simplify-high-performance-messaging-programming
Traits.hpp
1 #pragma once
2 
3 #include <type_traits>
4 #include <tuple>
5 
6 namespace hmbdc {
7 template <typename T>
8 struct function_traits: function_traits<decltype(&T::operator())>
9 {};
10 
11 template <typename ClassType, typename ReturnType, typename... Args>
12 struct function_traits<ReturnType(ClassType::*)(Args...) const> {
13  enum { arity = sizeof...(Args) };
14  typedef ReturnType result_type;
15 
16  template <size_t i>
17  struct arg {
18  using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
19  };
20 };
21 
22 template <typename ClassType, typename ReturnType, typename... Args>
23 struct function_traits<ReturnType(ClassType::*)(Args...)> {
24  enum { arity = sizeof...(Args) };
25 
26  typedef ReturnType result_type;
27 
28  template <size_t i>
29  struct arg {
30  using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
31  };
32 };
33 
34 template <typename Base, typename Derived>
36  enum {
37  value = std::is_base_of<Base, Derived>::value
38  //&& (Base const*)((Derived const*)0xffff) == ((Base const*)0xffff) - not supported on some compilers
39  };
40 };
41 
42 template <typename T, typename Tuple>
44 
45 template <typename T, typename... Types>
46 struct index_in_tuple<T, std::tuple<T, Types...>> {
47  static const std::size_t value = 0;
48 };
49 
50 template <typename T>
51 struct index_in_tuple<T, std::tuple<>> {
52  static const std::size_t value = 0;
53 };
54 
55 template <typename T, typename U, typename... Types>
56 struct index_in_tuple<T, std::tuple<U, Types...>> {
57  static const std::size_t value = 1 + index_in_tuple<T, std::tuple<Types...>>::value;
58 };
59 
60 
61 template <typename T, typename Tuple>
63  using type = std::tuple<T>;
64 };
65 
66 template <typename T, typename... Types>
67 struct add_if_not_in_tuple<T, std::tuple<Types ...>> {
68 private:
69  using Tuple = std::tuple<Types ...>;
70 public:
71  using type = typename std::conditional<
72  index_in_tuple<T, Tuple>::value == sizeof...(Types)
73  , std::tuple<Types ..., T>
74  , Tuple
75  >::type;
76 };
77 
78 template <typename Tuple1, typename Tuple2>
80 
81 template <typename Tuple1>
82 struct merge_tuple_unique<Tuple1, std::tuple<>> {
83  using type = Tuple1;
84 };
85 
86 template <typename Tuple1, typename T, typename... Types>
87 struct merge_tuple_unique<Tuple1, std::tuple<T, Types...>> {
88 private:
89  using step1 = typename add_if_not_in_tuple<T, Tuple1>::type;
90 public:
91  using type = typename merge_tuple_unique<step1, std::tuple<Types...>>::type;
92 };
93 
94 template <typename Tuple>
96  static const std::size_t value = 0;
97 };
98 
99 template <typename T, typename... Ts>
100 struct max_size_in_tuple<std::tuple<T, Ts...>> {
101 private:
102  static const std::size_t step1 = max_size_in_tuple<std::tuple<Ts...>>::value;
103 public:
104  static const std::size_t value = step1 > sizeof(T) ? step1 : sizeof(T);
105 };
106 
107 // template <typename... Types> struct concat_tuple;
108 // template <template <typename...> typename P, typename... Ts, typename... Us>
109 // struct concat_tuple<P<Ts...>, P<Us...>> {
110 // using type = P<Ts..., Us...>;
111 // };
112 
113 // template <typename Pack1, typename Pack2, typename... Types>
114 // struct concat_tuple<Pack1, Pack2, Types...> : concat_tupl<Pack1, typename concat_tupl<Pack2, Types...>::type> {};
115 
116 }
Definition: Traits.hpp:79
Definition: TypedString.hpp:74
Definition: Traits.hpp:43
Definition: Traits.hpp:35
Definition: Traits.hpp:62
Definition: Traits.hpp:95
Definition: Base.hpp:12
Definition: Traits.hpp:8