variant.hpp 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434
  1. // This file is part of OpenCV project.
  2. // It is subject to the license terms in the LICENSE file found in the top-level directory
  3. // of this distribution and at http://opencv.org/license.html.
  4. //
  5. // Copyright (C) 2018 Intel Corporation
  6. #ifndef OPENCV_GAPI_UTIL_VARIANT_HPP
  7. #define OPENCV_GAPI_UTIL_VARIANT_HPP
  8. #include <array>
  9. #include <type_traits>
  10. #include <opencv2/gapi/util/throw.hpp>
  11. #include <opencv2/gapi/util/util.hpp> // max_of_t
  12. #include <opencv2/gapi/util/type_traits.hpp>
  13. // A poor man's `variant` implementation, incompletely modeled against C++17 spec.
  14. namespace cv
  15. {
  16. namespace util
  17. {
  18. namespace detail
  19. {
  20. template<std::size_t I, typename Target, typename First, typename... Remaining>
  21. struct type_list_index_helper
  22. {
  23. static const constexpr bool is_same = std::is_same<Target, First>::value;
  24. static const constexpr std::size_t value =
  25. std::conditional<is_same, std::integral_constant<std::size_t, I>, type_list_index_helper<I + 1, Target, Remaining...>>::type::value;
  26. };
  27. template<std::size_t I, typename Target, typename First>
  28. struct type_list_index_helper<I, Target, First>
  29. {
  30. static_assert(std::is_same<Target, First>::value, "Type not found");
  31. static const constexpr std::size_t value = I;
  32. };
  33. }
  34. template<typename Target, typename... Types>
  35. struct type_list_index
  36. {
  37. static const constexpr std::size_t value = detail::type_list_index_helper<0, Target, Types...>::value;
  38. };
  39. class bad_variant_access: public std::exception
  40. {
  41. public:
  42. virtual const char *what() const noexcept override
  43. {
  44. return "Bad variant access";
  45. }
  46. };
  47. // Interface ///////////////////////////////////////////////////////////////
  48. struct monostate {};
  49. inline bool operator==(const util::monostate&, const util::monostate&)
  50. {
  51. return true;
  52. }
  53. template<typename... Ts> // FIXME: no references, arrays, and void
  54. class variant
  55. {
  56. // FIXME: Replace with std::aligned_union after gcc4.8 support is dropped
  57. static constexpr const std::size_t S = cv::detail::max_of_t<sizeof(Ts)...>::value;
  58. static constexpr const std::size_t A = cv::detail::max_of_t<alignof(Ts)...>::value;
  59. using Memory = typename std::aligned_storage<S, A>::type[1];
  60. template<typename T> struct cctr_h {
  61. static void help(Memory memory, const Memory from) {
  62. new (memory) T(*reinterpret_cast<const T*>(from));
  63. }
  64. };
  65. template<typename T> struct mctr_h {
  66. static void help(Memory memory, void *pval) {
  67. new (memory) T(std::move(*reinterpret_cast<T*>(pval)));
  68. }
  69. };
  70. //FIXME: unify with cctr_h and mctr_h
  71. template<typename T> struct cnvrt_ctor_h {
  72. static void help(Memory memory, void* from) {
  73. using util::decay_t;
  74. new (memory) decay_t<T>(std::forward<T>(*reinterpret_cast<decay_t<T>*>(from)));
  75. }
  76. };
  77. template<typename T> struct copy_h {
  78. static void help(Memory to, const Memory from) {
  79. *reinterpret_cast<T*>(to) = *reinterpret_cast<const T*>(from);
  80. }
  81. };
  82. template<typename T> struct move_h {
  83. static void help(Memory to, Memory from) {
  84. *reinterpret_cast<T*>(to) = std::move(*reinterpret_cast<T*>(from));
  85. }
  86. };
  87. //FIXME: unify with copy_h and move_h
  88. template<typename T> struct cnvrt_assign_h {
  89. static void help(Memory to, void* from) {
  90. using util::decay_t;
  91. *reinterpret_cast<decay_t<T>*>(to) = std::forward<T>(*reinterpret_cast<decay_t<T>*>(from));
  92. }
  93. };
  94. template<typename T> struct swap_h {
  95. static void help(Memory to, Memory from) {
  96. std::swap(*reinterpret_cast<T*>(to), *reinterpret_cast<T*>(from));
  97. }
  98. };
  99. template<typename T> struct dtor_h {
  100. static void help(Memory memory) {
  101. (void) memory; // MSCV warning
  102. reinterpret_cast<T*>(memory)->~T();
  103. }
  104. };
  105. template<typename T> struct equal_h {
  106. static bool help(const Memory lhs, const Memory rhs) {
  107. const T& t_lhs = *reinterpret_cast<const T*>(lhs);
  108. const T& t_rhs = *reinterpret_cast<const T*>(rhs);
  109. return t_lhs == t_rhs;
  110. }
  111. };
  112. typedef void (*CCtr) (Memory, const Memory); // Copy c-tor (variant)
  113. typedef void (*MCtr) (Memory, void*); // Generic move c-tor
  114. typedef void (*Copy) (Memory, const Memory); // Copy assignment
  115. typedef void (*Move) (Memory, Memory); // Move assignment
  116. typedef void (*Swap) (Memory, Memory); // Swap
  117. typedef void (*Dtor) (Memory); // Destructor
  118. using cnvrt_assgn_t = void (*) (Memory, void*); // Converting assignment (via std::forward)
  119. using cnvrt_ctor_t = void (*) (Memory, void*); // Converting constructor (via std::forward)
  120. typedef bool (*Equal)(const Memory, const Memory); // Equality test (external)
  121. static constexpr std::array<CCtr, sizeof...(Ts)> cctrs(){ return {{(&cctr_h<Ts>::help)...}};}
  122. static constexpr std::array<MCtr, sizeof...(Ts)> mctrs(){ return {{(&mctr_h<Ts>::help)...}};}
  123. static constexpr std::array<Copy, sizeof...(Ts)> cpyrs(){ return {{(&copy_h<Ts>::help)...}};}
  124. static constexpr std::array<Move, sizeof...(Ts)> mvers(){ return {{(&move_h<Ts>::help)...}};}
  125. static constexpr std::array<Swap, sizeof...(Ts)> swprs(){ return {{(&swap_h<Ts>::help)...}};}
  126. static constexpr std::array<Dtor, sizeof...(Ts)> dtors(){ return {{(&dtor_h<Ts>::help)...}};}
  127. template<bool cond, typename T>
  128. struct conditional_ref : std::conditional<cond, typename std::remove_reference<T>::type&, typename std::remove_reference<T>::type > {};
  129. template<bool cond, typename T>
  130. using conditional_ref_t = typename conditional_ref<cond, T>::type;
  131. template<bool is_lvalue_arg>
  132. static constexpr std::array<cnvrt_assgn_t, sizeof...(Ts)> cnvrt_assgnrs(){
  133. return {{(&cnvrt_assign_h<conditional_ref_t<is_lvalue_arg,Ts>>::help)...}};
  134. }
  135. template<bool is_lvalue_arg>
  136. static constexpr std::array<cnvrt_ctor_t, sizeof...(Ts)> cnvrt_ctors(){
  137. return {{(&cnvrt_ctor_h<conditional_ref_t<is_lvalue_arg,Ts>>::help)...}};
  138. }
  139. std::size_t m_index = 0;
  140. protected:
  141. template<typename T, typename... Us> friend T& get(variant<Us...> &v);
  142. template<typename T, typename... Us> friend const T& get(const variant<Us...> &v);
  143. template<typename T, typename... Us> friend T* get_if(variant<Us...> *v) noexcept;
  144. template<typename T, typename... Us> friend const T* get_if(const variant<Us...> *v) noexcept;
  145. template<typename... Us> friend bool operator==(const variant<Us...> &lhs,
  146. const variant<Us...> &rhs);
  147. Memory memory;
  148. public:
  149. // Constructors
  150. variant() noexcept;
  151. variant(const variant& other);
  152. variant(variant&& other) noexcept;
  153. // are_different_t is a SFINAE trick to avoid variant(T &&t) with T=variant
  154. // for some reason, this version is called instead of variant(variant&& o) when
  155. // variant is used in STL containers (examples: vector assignment).
  156. template<
  157. typename T,
  158. typename = util::are_different_t<variant, T>
  159. >
  160. explicit variant(T&& t);
  161. // template<class T, class... Args> explicit variant(Args&&... args);
  162. // FIXME: other constructors
  163. // Destructor
  164. ~variant();
  165. // Assignment
  166. variant& operator=(const variant& rhs);
  167. variant& operator=(variant &&rhs) noexcept;
  168. // SFINAE trick to avoid operator=(T&&) with T=variant<>, see comment above
  169. template<
  170. typename T,
  171. typename = util::are_different_t<variant, T>
  172. >
  173. variant& operator=(T&& t) noexcept;
  174. // Observers
  175. std::size_t index() const noexcept;
  176. // FIXME: valueless_by_exception()
  177. // Modifiers
  178. // FIXME: emplace()
  179. void swap(variant &rhs) noexcept;
  180. // Non-C++17x!
  181. template<typename T> static constexpr std::size_t index_of();
  182. };
  183. // FIMXE: visit
  184. template<typename T, typename... Types>
  185. T* get_if(util::variant<Types...>* v) noexcept;
  186. template<typename T, typename... Types>
  187. const T* get_if(const util::variant<Types...>* v) noexcept;
  188. template<typename T, typename... Types>
  189. T& get(util::variant<Types...> &v);
  190. template<typename T, typename... Types>
  191. const T& get(const util::variant<Types...> &v);
  192. template<typename T, typename... Types>
  193. bool holds_alternative(const util::variant<Types...> &v) noexcept;
  194. // FIXME: T&&, const TT&& versions.
  195. // Implementation //////////////////////////////////////////////////////////
  196. template<typename... Ts>
  197. variant<Ts...>::variant() noexcept
  198. {
  199. typedef typename std::tuple_element<0, std::tuple<Ts...> >::type TFirst;
  200. new (memory) TFirst();
  201. }
  202. template<typename... Ts>
  203. variant<Ts...>::variant(const variant &other)
  204. : m_index(other.m_index)
  205. {
  206. (cctrs()[m_index])(memory, other.memory);
  207. }
  208. template<typename... Ts>
  209. variant<Ts...>::variant(variant &&other) noexcept
  210. : m_index(other.m_index)
  211. {
  212. (mctrs()[m_index])(memory, other.memory);
  213. }
  214. template<typename... Ts>
  215. template<class T, typename>
  216. variant<Ts...>::variant(T&& t)
  217. : m_index(util::type_list_index<util::decay_t<T>, Ts...>::value)
  218. {
  219. const constexpr bool is_lvalue_arg = std::is_lvalue_reference<T>::value;
  220. (cnvrt_ctors<is_lvalue_arg>()[m_index])(memory, const_cast<util::decay_t<T> *>(&t));
  221. }
  222. template<typename... Ts>
  223. variant<Ts...>::~variant()
  224. {
  225. (dtors()[m_index])(memory);
  226. }
  227. template<typename... Ts>
  228. variant<Ts...>& variant<Ts...>::operator=(const variant<Ts...> &rhs)
  229. {
  230. if (m_index != rhs.m_index)
  231. {
  232. (dtors()[ m_index])(memory);
  233. (cctrs()[rhs.m_index])(memory, rhs.memory);
  234. m_index = rhs.m_index;
  235. }
  236. else
  237. {
  238. (cpyrs()[rhs.m_index])(memory, rhs.memory);
  239. }
  240. return *this;
  241. }
  242. template<typename... Ts>
  243. variant<Ts...>& variant<Ts...>::operator=(variant<Ts...> &&rhs) noexcept
  244. {
  245. if (m_index != rhs.m_index)
  246. {
  247. (dtors()[ m_index])(memory);
  248. (mctrs()[rhs.m_index])(memory, rhs.memory);
  249. m_index = rhs.m_index;
  250. }
  251. else
  252. {
  253. (mvers()[rhs.m_index])(memory, rhs.memory);
  254. }
  255. return *this;
  256. }
  257. template<typename... Ts>
  258. template<typename T, typename>
  259. variant<Ts...>& variant<Ts...>::operator=(T&& t) noexcept
  260. {
  261. using decayed_t = util::decay_t<T>;
  262. // FIXME: No version with implicit type conversion available!
  263. const constexpr std::size_t t_index =
  264. util::type_list_index<decayed_t, Ts...>::value;
  265. const constexpr bool is_lvalue_arg = std::is_lvalue_reference<T>::value;
  266. if (t_index != m_index)
  267. {
  268. (dtors()[m_index])(memory);
  269. (cnvrt_ctors<is_lvalue_arg>()[t_index])(memory, &t);
  270. m_index = t_index;
  271. }
  272. else
  273. {
  274. (cnvrt_assgnrs<is_lvalue_arg>()[m_index])(memory, &t);
  275. }
  276. return *this;
  277. }
  278. template<typename... Ts>
  279. std::size_t util::variant<Ts...>::index() const noexcept
  280. {
  281. return m_index;
  282. }
  283. template<typename... Ts>
  284. void variant<Ts...>::swap(variant<Ts...> &rhs) noexcept
  285. {
  286. if (m_index == rhs.index())
  287. {
  288. (swprs()[m_index](memory, rhs.memory));
  289. }
  290. else
  291. {
  292. variant<Ts...> tmp(std::move(*this));
  293. *this = std::move(rhs);
  294. rhs = std::move(tmp);
  295. }
  296. }
  297. template<typename... Ts>
  298. template<typename T>
  299. constexpr std::size_t variant<Ts...>::index_of()
  300. {
  301. return util::type_list_index<T, Ts...>::value; // FIXME: tests!
  302. }
  303. template<typename T, typename... Types>
  304. T* get_if(util::variant<Types...>* v) noexcept
  305. {
  306. const constexpr std::size_t t_index =
  307. util::type_list_index<T, Types...>::value;
  308. if (v && v->index() == t_index)
  309. return (T*)(&v->memory); // workaround for ICC 2019
  310. // original code: return reinterpret_cast<T&>(v.memory);
  311. return nullptr;
  312. }
  313. template<typename T, typename... Types>
  314. const T* get_if(const util::variant<Types...>* v) noexcept
  315. {
  316. const constexpr std::size_t t_index =
  317. util::type_list_index<T, Types...>::value;
  318. if (v && v->index() == t_index)
  319. return (const T*)(&v->memory); // workaround for ICC 2019
  320. // original code: return reinterpret_cast<const T&>(v.memory);
  321. return nullptr;
  322. }
  323. template<typename T, typename... Types>
  324. T& get(util::variant<Types...> &v)
  325. {
  326. if (auto* p = get_if<T>(&v))
  327. return *p;
  328. else
  329. throw_error(bad_variant_access());
  330. }
  331. template<typename T, typename... Types>
  332. const T& get(const util::variant<Types...> &v)
  333. {
  334. if (auto* p = get_if<T>(&v))
  335. return *p;
  336. else
  337. throw_error(bad_variant_access());
  338. }
  339. template<typename T, typename... Types>
  340. bool holds_alternative(const util::variant<Types...> &v) noexcept
  341. {
  342. return v.index() == util::variant<Types...>::template index_of<T>();
  343. }
  344. template<typename... Us> bool operator==(const variant<Us...> &lhs,
  345. const variant<Us...> &rhs)
  346. {
  347. using V = variant<Us...>;
  348. // Instantiate table only here since it requires operator== for <Us...>
  349. // <Us...> should have operator== only if this one is used, not in general
  350. static const std::array<typename V::Equal, sizeof...(Us)> eqs = {
  351. {(&V::template equal_h<Us>::help)...}
  352. };
  353. if (lhs.index() != rhs.index())
  354. return false;
  355. return (eqs[lhs.index()])(lhs.memory, rhs.memory);
  356. }
  357. template<typename... Us> bool operator!=(const variant<Us...> &lhs,
  358. const variant<Us...> &rhs)
  359. {
  360. return !(lhs == rhs);
  361. }
  362. } // namespace cv
  363. } // namespace util
  364. #endif // OPENCV_GAPI_UTIL_VARIANT_HPP