BVB Source Codes

mars Show storage_type.hpp Source code

Return Download mars: download storage_type.hpp Source code - Download mars Source code - Type:.hpp
  1. /*
  2.  * Distributed under the Boost Software License, Version 1.0.
  3.  * (See accompanying file LICENSE_1_0.txt or copy at
  4.  * http://www.boost.org/LICENSE_1_0.txt)
  5.  *
  6.  * Copyright (c) 2009 Helge Bahmann
  7.  * Copyright (c) 2012 Tim Blechmann
  8.  * Copyright (c) 2013 - 2014 Andrey Semashev
  9.  */
  10. /*!
  11.  * \file   atomic/detail/storage_type.hpp
  12.  *
  13.  * This header defines underlying types used as storage
  14.  */
  15.  
  16. #ifndef BOOST_ATOMIC_DETAIL_STORAGE_TYPE_HPP_INCLUDED_
  17. #define BOOST_ATOMIC_DETAIL_STORAGE_TYPE_HPP_INCLUDED_
  18.  
  19. #include <cstddef>
  20. #include <boost/cstdint.hpp>
  21. #include <boost/atomic/detail/config.hpp>
  22. #if !defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCMP) || !defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY)
  23. #include <cstring>
  24. #endif
  25.  
  26. #ifdef BOOST_HAS_PRAGMA_ONCE
  27. #pragma once
  28. #endif
  29.  
  30. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  31. namespace atomics {
  32. namespace detail {
  33.  
  34. template< typename T >
  35. BOOST_FORCEINLINE void non_atomic_load(T const volatile& from, T& to) BOOST_NOEXCEPT
  36. {
  37.     to = from;
  38. }
  39.  
  40. template< std::size_t Size >
  41. struct buffer_storage
  42. {
  43.     BOOST_ALIGNMENT(16) unsigned char data[Size];
  44.  
  45.     BOOST_FORCEINLINE bool operator! () const BOOST_NOEXCEPT
  46.     {
  47.         return (data[0] == 0u && BOOST_ATOMIC_DETAIL_MEMCMP(data, data + 1, Size - 1) == 0);
  48.     }
  49.  
  50.     BOOST_FORCEINLINE bool operator== (buffer_storage const& that) const BOOST_NOEXCEPT
  51.     {
  52.         return BOOST_ATOMIC_DETAIL_MEMCMP(data, that.data, Size) == 0;
  53.     }
  54.  
  55.     BOOST_FORCEINLINE bool operator!= (buffer_storage const& that) const BOOST_NOEXCEPT
  56.     {
  57.         return BOOST_ATOMIC_DETAIL_MEMCMP(data, that.data, Size) != 0;
  58.     }
  59. };
  60.  
  61. template< std::size_t Size >
  62. BOOST_FORCEINLINE void non_atomic_load(buffer_storage< Size > const volatile& from, buffer_storage< Size >& to) BOOST_NOEXCEPT
  63. {
  64.     BOOST_ATOMIC_DETAIL_MEMCPY(to.data, const_cast< unsigned char const* >(from.data), Size);
  65. }
  66.  
  67. template< std::size_t Size, bool Signed >
  68. struct make_storage_type
  69. {
  70.     typedef buffer_storage< Size > type;
  71.  
  72.     struct aligned
  73.     {
  74.         type value;
  75.  
  76.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  77.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type const& v) BOOST_NOEXCEPT : value(v) {}
  78.     };
  79. };
  80.  
  81. template< >
  82. struct make_storage_type< 1u, false >
  83. {
  84.     typedef mars_boost::uint8_t type;
  85.  
  86.     struct aligned
  87.     {
  88.         type value;
  89.  
  90.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  91.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  92.     };
  93. };
  94.  
  95. template< >
  96. struct make_storage_type< 1u, true >
  97. {
  98.     typedef mars_boost::int8_t type;
  99.  
  100.     struct aligned
  101.     {
  102.         type value;
  103.  
  104.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  105.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  106.     };
  107. };
  108.  
  109. template< >
  110. struct make_storage_type< 2u, false >
  111. {
  112.     typedef mars_boost::uint16_t type;
  113.  
  114.     struct aligned
  115.     {
  116.         BOOST_ALIGNMENT(2) type value;
  117.  
  118.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  119.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  120.     };
  121. };
  122.  
  123. template< >
  124. struct make_storage_type< 2u, true >
  125. {
  126.     typedef mars_boost::int16_t type;
  127.  
  128.     struct aligned
  129.     {
  130.         BOOST_ALIGNMENT(2) type value;
  131.  
  132.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  133.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  134.     };
  135. };
  136.  
  137. template< >
  138. struct make_storage_type< 4u, false >
  139. {
  140.     typedef mars_boost::uint32_t type;
  141.  
  142.     struct aligned
  143.     {
  144.         BOOST_ALIGNMENT(4) type value;
  145.  
  146.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  147.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  148.     };
  149. };
  150.  
  151. template< >
  152. struct make_storage_type< 4u, true >
  153. {
  154.     typedef mars_boost::int32_t type;
  155.  
  156.     struct aligned
  157.     {
  158.         BOOST_ALIGNMENT(4) type value;
  159.  
  160.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  161.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  162.     };
  163. };
  164.  
  165. template< >
  166. struct make_storage_type< 8u, false >
  167. {
  168.     typedef mars_boost::uint64_t type;
  169.  
  170.     struct aligned
  171.     {
  172.         BOOST_ALIGNMENT(8) type value;
  173.  
  174.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  175.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  176.     };
  177. };
  178.  
  179. template< >
  180. struct make_storage_type< 8u, true >
  181. {
  182.     typedef mars_boost::int64_t type;
  183.  
  184.     struct aligned
  185.     {
  186.         BOOST_ALIGNMENT(8) type value;
  187.  
  188.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  189.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  190.     };
  191. };
  192.  
  193. #if defined(BOOST_HAS_INT128)
  194.  
  195. template< >
  196. struct make_storage_type< 16u, false >
  197. {
  198.     typedef mars_boost::uint128_type type;
  199.  
  200.     struct aligned
  201.     {
  202.         BOOST_ALIGNMENT(16) type value;
  203.  
  204.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  205.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  206.     };
  207. };
  208.  
  209. template< >
  210. struct make_storage_type< 16u, true >
  211. {
  212.     typedef mars_boost::int128_type type;
  213.  
  214.     struct aligned
  215.     {
  216.         BOOST_ALIGNMENT(16) type value;
  217.  
  218.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  219.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {}
  220.     };
  221. };
  222.  
  223. #elif !defined(BOOST_NO_ALIGNMENT)
  224.  
  225. struct storage128_t
  226. {
  227.     mars_boost::uint64_t data[2];
  228.  
  229.     BOOST_FORCEINLINE bool operator! () const BOOST_NOEXCEPT
  230.     {
  231.         return data[0] == 0 && data[1] == 0;
  232.     }
  233. };
  234.  
  235. BOOST_FORCEINLINE bool operator== (storage128_t const& left, storage128_t const& right) BOOST_NOEXCEPT
  236. {
  237.     return left.data[0] == right.data[0] && left.data[1] == right.data[1];
  238. }
  239. BOOST_FORCEINLINE bool operator!= (storage128_t const& left, storage128_t const& right) BOOST_NOEXCEPT
  240. {
  241.     return !(left == right);
  242. }
  243.  
  244. BOOST_FORCEINLINE void non_atomic_load(storage128_t const volatile& from, storage128_t& to) BOOST_NOEXCEPT
  245. {
  246.     to.data[0] = from.data[0];
  247.     to.data[1] = from.data[1];
  248. }
  249.  
  250. template< bool Signed >
  251. struct make_storage_type< 16u, Signed >
  252. {
  253.     typedef storage128_t type;
  254.  
  255.     struct aligned
  256.     {
  257.         BOOST_ALIGNMENT(16) type value;
  258.  
  259.         BOOST_DEFAULTED_FUNCTION(aligned(), {})
  260.         BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type const& v) BOOST_NOEXCEPT : value(v) {}
  261.     };
  262. };
  263.  
  264. #endif
  265.  
  266. template< typename T >
  267. struct storage_size_of
  268. {
  269.     enum _
  270.     {
  271.         size = sizeof(T),
  272.         value = (size == 3 ? 4 : (size >= 5 && size <= 7 ? 8 : (size >= 9 && size <= 15 ? 16 : size)))
  273.     };
  274. };
  275.  
  276. } // namespace detail
  277. } // namespace atomics
  278. } // namespace mars_boost
  279.  
  280. #endif // BOOST_ATOMIC_DETAIL_STORAGE_TYPE_HPP_INCLUDED_
  281.  
downloadstorage_type.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top