9
3

arithmetic.hpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361
  1. // boost/endian/arithmetic.hpp -------------------------------------------------------//
  2. // (C) Copyright Darin Adler 2000
  3. // (C) Copyright Beman Dawes 2006, 2009, 2014
  4. // (C) Copyright Peter Dimov 2019
  5. // Distributed under the Boost Software License, Version 1.0.
  6. // See http://www.boost.org/LICENSE_1_0.txt
  7. // See library home page at http://www.boost.org/libs/endian
  8. //--------------------------------------------------------------------------------------//
  9. // Original design developed by Darin Adler based on classes developed by Mark
  10. // Borgerding. Four original class templates were combined into a single endian
  11. // class template by Beman Dawes, who also added the unrolled_byte_loops sign
  12. // partial specialization to correctly extend the sign when cover integer size
  13. // differs from endian representation size.
  14. // TODO: When a compiler supporting constexpr becomes available, try possible uses.
  15. #ifndef BOOST_ENDIAN_ARITHMETIC_HPP
  16. #define BOOST_ENDIAN_ARITHMETIC_HPP
  17. #if defined(_MSC_VER)
  18. # pragma warning(push)
  19. # pragma warning(disable:4365) // conversion ... signed/unsigned mismatch
  20. #endif
  21. #include <boost/endian/buffers.hpp>
  22. #include <boost/core/scoped_enum.hpp>
  23. #include <boost/predef/other/endian.h>
  24. #include <boost/static_assert.hpp>
  25. #include <boost/cstdint.hpp>
  26. #include <boost/config.hpp>
  27. #include <boost/config/workaround.hpp>
  28. #include <iosfwd>
  29. #include <climits>
  30. #if defined(__BORLANDC__) || defined( __CODEGEARC__)
  31. # pragma pack(push, 1)
  32. #endif
  33. # if CHAR_BIT != 8
  34. # error Platforms with CHAR_BIT != 8 are not supported
  35. # endif
  36. # ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
  37. # define BOOST_ENDIAN_DEFAULT_CONSTRUCT {} // C++03
  38. # else
  39. # define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default; // C++0x
  40. # endif
  41. // g++ pre-4.6 does not support unrestricted unions, but we have no Config macro for that
  42. # if (defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || BOOST_WORKAROUND(BOOST_GCC, < 40600)) && defined(BOOST_ENDIAN_FORCE_PODNESS)
  43. # define BOOST_ENDIAN_NO_CTORS
  44. # endif
  45. # ifndef BOOST_ENDIAN_EXPLICIT_CTORS
  46. # define BOOST_ENDIAN_EXPLICIT_OPT
  47. # else
  48. # define BOOST_ENDIAN_EXPLICIT_OPT explicit
  49. # endif
  50. //---------------------------------- synopsis ----------------------------------------//
  51. namespace boost
  52. {
  53. namespace endian
  54. {
  55. template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
  56. BOOST_SCOPED_ENUM(align) Align = align::no>
  57. class endian_arithmetic;
  58. // big endian signed integer aligned types
  59. typedef endian_arithmetic<order::big, int8_t, 8, align::yes> big_int8_at;
  60. typedef endian_arithmetic<order::big, int16_t, 16, align::yes> big_int16_at;
  61. typedef endian_arithmetic<order::big, int32_t, 32, align::yes> big_int32_at;
  62. typedef endian_arithmetic<order::big, int64_t, 64, align::yes> big_int64_at;
  63. // big endian unsigned integer aligned types
  64. typedef endian_arithmetic<order::big, uint8_t, 8, align::yes> big_uint8_at;
  65. typedef endian_arithmetic<order::big, uint16_t, 16, align::yes> big_uint16_at;
  66. typedef endian_arithmetic<order::big, uint32_t, 32, align::yes> big_uint32_at;
  67. typedef endian_arithmetic<order::big, uint64_t, 64, align::yes> big_uint64_at;
  68. // little endian signed integer aligned types
  69. typedef endian_arithmetic<order::little, int8_t, 8, align::yes> little_int8_at;
  70. typedef endian_arithmetic<order::little, int16_t, 16, align::yes> little_int16_at;
  71. typedef endian_arithmetic<order::little, int32_t, 32, align::yes> little_int32_at;
  72. typedef endian_arithmetic<order::little, int64_t, 64, align::yes> little_int64_at;
  73. // little endian unsigned integer aligned types
  74. typedef endian_arithmetic<order::little, uint8_t, 8, align::yes> little_uint8_at;
  75. typedef endian_arithmetic<order::little, uint16_t, 16, align::yes> little_uint16_at;
  76. typedef endian_arithmetic<order::little, uint32_t, 32, align::yes> little_uint32_at;
  77. typedef endian_arithmetic<order::little, uint64_t, 64, align::yes> little_uint64_at;
  78. // aligned floating point types
  79. typedef endian_arithmetic<order::big, float, 32, align::yes> big_float32_at;
  80. typedef endian_arithmetic<order::big, double, 64, align::yes> big_float64_at;
  81. typedef endian_arithmetic<order::little, float, 32, align::yes> little_float32_at;
  82. typedef endian_arithmetic<order::little, double, 64, align::yes> little_float64_at;
  83. // aligned native endian typedefs are not provided because
  84. // <cstdint> types are superior for this use case
  85. // big endian signed integer unaligned types
  86. typedef endian_arithmetic<order::big, int_least8_t, 8> big_int8_t;
  87. typedef endian_arithmetic<order::big, int_least16_t, 16> big_int16_t;
  88. typedef endian_arithmetic<order::big, int_least32_t, 24> big_int24_t;
  89. typedef endian_arithmetic<order::big, int_least32_t, 32> big_int32_t;
  90. typedef endian_arithmetic<order::big, int_least64_t, 40> big_int40_t;
  91. typedef endian_arithmetic<order::big, int_least64_t, 48> big_int48_t;
  92. typedef endian_arithmetic<order::big, int_least64_t, 56> big_int56_t;
  93. typedef endian_arithmetic<order::big, int_least64_t, 64> big_int64_t;
  94. // big endian unsigned integer unaligned types
  95. typedef endian_arithmetic<order::big, uint_least8_t, 8> big_uint8_t;
  96. typedef endian_arithmetic<order::big, uint_least16_t, 16> big_uint16_t;
  97. typedef endian_arithmetic<order::big, uint_least32_t, 24> big_uint24_t;
  98. typedef endian_arithmetic<order::big, uint_least32_t, 32> big_uint32_t;
  99. typedef endian_arithmetic<order::big, uint_least64_t, 40> big_uint40_t;
  100. typedef endian_arithmetic<order::big, uint_least64_t, 48> big_uint48_t;
  101. typedef endian_arithmetic<order::big, uint_least64_t, 56> big_uint56_t;
  102. typedef endian_arithmetic<order::big, uint_least64_t, 64> big_uint64_t;
  103. // little endian signed integer unaligned types
  104. typedef endian_arithmetic<order::little, int_least8_t, 8> little_int8_t;
  105. typedef endian_arithmetic<order::little, int_least16_t, 16> little_int16_t;
  106. typedef endian_arithmetic<order::little, int_least32_t, 24> little_int24_t;
  107. typedef endian_arithmetic<order::little, int_least32_t, 32> little_int32_t;
  108. typedef endian_arithmetic<order::little, int_least64_t, 40> little_int40_t;
  109. typedef endian_arithmetic<order::little, int_least64_t, 48> little_int48_t;
  110. typedef endian_arithmetic<order::little, int_least64_t, 56> little_int56_t;
  111. typedef endian_arithmetic<order::little, int_least64_t, 64> little_int64_t;
  112. // little endian unsigned integer unaligned types
  113. typedef endian_arithmetic<order::little, uint_least8_t, 8> little_uint8_t;
  114. typedef endian_arithmetic<order::little, uint_least16_t, 16> little_uint16_t;
  115. typedef endian_arithmetic<order::little, uint_least32_t, 24> little_uint24_t;
  116. typedef endian_arithmetic<order::little, uint_least32_t, 32> little_uint32_t;
  117. typedef endian_arithmetic<order::little, uint_least64_t, 40> little_uint40_t;
  118. typedef endian_arithmetic<order::little, uint_least64_t, 48> little_uint48_t;
  119. typedef endian_arithmetic<order::little, uint_least64_t, 56> little_uint56_t;
  120. typedef endian_arithmetic<order::little, uint_least64_t, 64> little_uint64_t;
  121. # if BOOST_ENDIAN_BIG_BYTE
  122. // native endian signed integer unaligned types
  123. typedef big_int8_t native_int8_t;
  124. typedef big_int16_t native_int16_t;
  125. typedef big_int24_t native_int24_t;
  126. typedef big_int32_t native_int32_t;
  127. typedef big_int40_t native_int40_t;
  128. typedef big_int48_t native_int48_t;
  129. typedef big_int56_t native_int56_t;
  130. typedef big_int64_t native_int64_t;
  131. // native endian unsigned integer unaligned types
  132. typedef big_uint8_t native_uint8_t;
  133. typedef big_uint16_t native_uint16_t;
  134. typedef big_uint24_t native_uint24_t;
  135. typedef big_uint32_t native_uint32_t;
  136. typedef big_uint40_t native_uint40_t;
  137. typedef big_uint48_t native_uint48_t;
  138. typedef big_uint56_t native_uint56_t;
  139. typedef big_uint64_t native_uint64_t;
  140. # else
  141. // native endian signed integer unaligned types
  142. typedef little_int8_t native_int8_t;
  143. typedef little_int16_t native_int16_t;
  144. typedef little_int24_t native_int24_t;
  145. typedef little_int32_t native_int32_t;
  146. typedef little_int40_t native_int40_t;
  147. typedef little_int48_t native_int48_t;
  148. typedef little_int56_t native_int56_t;
  149. typedef little_int64_t native_int64_t;
  150. // native endian unsigned integer unaligned types
  151. typedef little_uint8_t native_uint8_t;
  152. typedef little_uint16_t native_uint16_t;
  153. typedef little_uint24_t native_uint24_t;
  154. typedef little_uint32_t native_uint32_t;
  155. typedef little_uint40_t native_uint40_t;
  156. typedef little_uint48_t native_uint48_t;
  157. typedef little_uint56_t native_uint56_t;
  158. typedef little_uint64_t native_uint64_t;
  159. # endif
  160. // unaligned floating point types
  161. typedef endian_arithmetic<order::big, float, 32, align::no> big_float32_t;
  162. typedef endian_arithmetic<order::big, double, 64, align::no> big_float64_t;
  163. typedef endian_arithmetic<order::little, float, 32, align::no> little_float32_t;
  164. typedef endian_arithmetic<order::little, double, 64, align::no> little_float64_t;
  165. typedef endian_arithmetic<order::native, float, 32, align::no> native_float32_t;
  166. typedef endian_arithmetic<order::native, double, 64, align::no> native_float64_t;
  167. //---------------------------------- end synopsis ------------------------------------//
  168. template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
  169. BOOST_SCOPED_ENUM(align) Align>
  170. class endian_arithmetic:
  171. public endian_buffer<Order, T, n_bits, Align>
  172. {
  173. private:
  174. typedef endian_buffer<Order, T, n_bits, Align> inherited;
  175. public:
  176. typedef T value_type;
  177. #ifndef BOOST_ENDIAN_NO_CTORS
  178. endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT
  179. BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic( T val ) BOOST_NOEXCEPT: inherited( val )
  180. {
  181. }
  182. #endif
  183. endian_arithmetic& operator=( T val ) BOOST_NOEXCEPT
  184. {
  185. inherited::operator=( val );
  186. return *this;
  187. }
  188. operator value_type() const BOOST_NOEXCEPT
  189. {
  190. return this->value();
  191. }
  192. // operators
  193. T operator+() const BOOST_NOEXCEPT
  194. {
  195. return this->value();
  196. }
  197. endian_arithmetic& operator+=( T y ) BOOST_NOEXCEPT
  198. {
  199. *this = static_cast<T>( this->value() + y );
  200. return *this;
  201. }
  202. endian_arithmetic& operator-=( T y ) BOOST_NOEXCEPT
  203. {
  204. *this = static_cast<T>( this->value() - y );
  205. return *this;
  206. }
  207. endian_arithmetic& operator*=( T y ) BOOST_NOEXCEPT
  208. {
  209. *this = static_cast<T>( this->value() * y );
  210. return *this;
  211. }
  212. endian_arithmetic& operator/=( T y ) BOOST_NOEXCEPT
  213. {
  214. *this = static_cast<T>( this->value() / y );
  215. return *this;
  216. }
  217. endian_arithmetic& operator%=( T y ) BOOST_NOEXCEPT
  218. {
  219. *this = static_cast<T>( this->value() % y );
  220. return *this;
  221. }
  222. endian_arithmetic& operator&=( T y ) BOOST_NOEXCEPT
  223. {
  224. *this = static_cast<T>( this->value() & y );
  225. return *this;
  226. }
  227. endian_arithmetic& operator|=( T y ) BOOST_NOEXCEPT
  228. {
  229. *this = static_cast<T>( this->value() | y );
  230. return *this;
  231. }
  232. endian_arithmetic& operator^=( T y ) BOOST_NOEXCEPT
  233. {
  234. *this = static_cast<T>( this->value() ^ y );
  235. return *this;
  236. }
  237. endian_arithmetic& operator<<=( T y ) BOOST_NOEXCEPT
  238. {
  239. *this = static_cast<T>( this->value() << y );
  240. return *this;
  241. }
  242. endian_arithmetic& operator>>=( T y ) BOOST_NOEXCEPT
  243. {
  244. *this = static_cast<T>( this->value() >> y );
  245. return *this;
  246. }
  247. endian_arithmetic& operator++() BOOST_NOEXCEPT
  248. {
  249. *this += 1;
  250. return *this;
  251. }
  252. endian_arithmetic& operator--() BOOST_NOEXCEPT
  253. {
  254. *this -= 1;
  255. return *this;
  256. }
  257. endian_arithmetic operator++(int) BOOST_NOEXCEPT
  258. {
  259. endian_arithmetic tmp( *this );
  260. *this += 1;
  261. return tmp;
  262. }
  263. endian_arithmetic operator--(int) BOOST_NOEXCEPT
  264. {
  265. endian_arithmetic tmp( *this );
  266. *this -= 1;
  267. return tmp;
  268. }
  269. template<class Ch, class Tr>
  270. friend std::basic_ostream<Ch, Tr>&
  271. operator<<( std::basic_ostream<Ch, Tr>& os, endian_arithmetic const& x )
  272. {
  273. return os << x.value();
  274. }
  275. template<class Ch, class Tr>
  276. friend std::basic_istream<Ch, Tr>&
  277. operator>>( std::basic_istream<Ch, Tr>& is, endian_arithmetic& x )
  278. {
  279. T i;
  280. if( is >> i )
  281. {
  282. x = i;
  283. }
  284. return is;
  285. }
  286. };
  287. } // namespace endian
  288. } // namespace boost
  289. #if defined(__BORLANDC__) || defined( __CODEGEARC__)
  290. # pragma pack(pop)
  291. #endif
  292. #if defined(_MSC_VER)
  293. # pragma warning(pop)
  294. #endif
  295. #endif // BOOST_ENDIAN_ARITHMETIC_HPP