1 // boost/endian/buffers.hpp ----------------------------------------------------------// 2 3 // (C) Copyright Darin Adler 2000 4 // (C) Copyright Beman Dawes 2006, 2009, 2014 5 // (C) Copyright Peter Dimov 2019 6 7 // Distributed under the Boost Software License, Version 1.0. 8 // See http://www.boost.org/LICENSE_1_0.txt 9 10 // See library home page at http://www.boost.org/libs/endian 11 12 //--------------------------------------------------------------------------------------// 13 14 // Original design developed by Darin Adler based on classes developed by Mark 15 // Borgerding. Four original class templates were combined into a single endian 16 // class template by Beman Dawes, who also added the unrolled_byte_loops sign 17 // partial specialization to correctly extend the sign when cover integer size 18 // differs from endian representation size. 19 20 // TODO: When a compiler supporting constexpr becomes available, try possible uses. 21 22 #ifndef BOOST_ENDIAN_BUFFERS_HPP 23 #define BOOST_ENDIAN_BUFFERS_HPP 24 25 #if defined(_MSC_VER) 26 # pragma warning(push) 27 # pragma warning(disable: 4127) // conditional expression is constant 28 #endif 29 30 #include <boost/endian/detail/endian_store.hpp> 31 #include <boost/endian/detail/endian_load.hpp> 32 #include <boost/core/scoped_enum.hpp> 33 #include <boost/static_assert.hpp> 34 #include <boost/cstdint.hpp> 35 #include <boost/config.hpp> 36 #include <boost/config/workaround.hpp> 37 #include <iosfwd> 38 #include <climits> 39 #include <cstring> 40 41 #if defined(BOOST_BORLANDC) || defined(BOOST_CODEGEARC) 42 # pragma pack(push, 1) 43 #endif 44 45 # if CHAR_BIT != 8 46 # error Platforms with CHAR_BIT != 8 are not supported 47 # endif 48 49 # ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS 50 # define BOOST_ENDIAN_DEFAULT_CONSTRUCT {} // C++03 51 # else 52 # define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default; // C++0x 53 # endif 54 55 // g++ pre-4.6 does not support unrestricted unions, but we have no Config macro for that 56 # if (defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || BOOST_WORKAROUND(BOOST_GCC, < 40600)) && defined(BOOST_ENDIAN_FORCE_PODNESS) 57 # define BOOST_ENDIAN_NO_CTORS 58 # endif 59 60 //---------------------------------- synopsis ----------------------------------------// 61 62 namespace boost 63 { 64 namespace endian 65 { 66 BOOST_SCOPED_ENUM_START(align)67 BOOST_SCOPED_ENUM_START(align) 68 {no, yes 69 # ifdef BOOST_ENDIAN_DEPRECATED_NAMES 70 , unaligned = no, aligned = yes 71 # endif 72 }; BOOST_SCOPED_ENUM_END 73 74 template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits, 75 BOOST_SCOPED_ENUM(align) A = align::no> 76 class endian_buffer; 77 78 // aligned big endian signed integer buffers 79 typedef endian_buffer<order::big, int8_t, 8, align::yes> big_int8_buf_at; 80 typedef endian_buffer<order::big, int16_t, 16, align::yes> big_int16_buf_at; 81 typedef endian_buffer<order::big, int32_t, 32, align::yes> big_int32_buf_at; 82 typedef endian_buffer<order::big, int64_t, 64, align::yes> big_int64_buf_at; 83 84 // aligned big endian unsigned integer buffers 85 typedef endian_buffer<order::big, uint8_t, 8, align::yes> big_uint8_buf_at; 86 typedef endian_buffer<order::big, uint16_t, 16, align::yes> big_uint16_buf_at; 87 typedef endian_buffer<order::big, uint32_t, 32, align::yes> big_uint32_buf_at; 88 typedef endian_buffer<order::big, uint64_t, 64, align::yes> big_uint64_buf_at; 89 90 // aligned little endian signed integer buffers 91 typedef endian_buffer<order::little, int8_t, 8, align::yes> little_int8_buf_at; 92 typedef endian_buffer<order::little, int16_t, 16, align::yes> little_int16_buf_at; 93 typedef endian_buffer<order::little, int32_t, 32, align::yes> little_int32_buf_at; 94 typedef endian_buffer<order::little, int64_t, 64, align::yes> little_int64_buf_at; 95 96 // aligned little endian unsigned integer buffers 97 typedef endian_buffer<order::little, uint8_t, 8, align::yes> little_uint8_buf_at; 98 typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_at; 99 typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_at; 100 typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_at; 101 102 // aligned floating point buffers 103 typedef endian_buffer<order::big, float, 32, align::yes> big_float32_buf_at; 104 typedef endian_buffer<order::big, double, 64, align::yes> big_float64_buf_at; 105 typedef endian_buffer<order::little, float, 32, align::yes> little_float32_buf_at; 106 typedef endian_buffer<order::little, double, 64, align::yes> little_float64_buf_at; 107 108 // aligned native endian typedefs are not provided because 109 // <cstdint> types are superior for this use case 110 111 // unaligned big endian signed integer buffers 112 typedef endian_buffer<order::big, int_least8_t, 8> big_int8_buf_t; 113 typedef endian_buffer<order::big, int_least16_t, 16> big_int16_buf_t; 114 typedef endian_buffer<order::big, int_least32_t, 24> big_int24_buf_t; 115 typedef endian_buffer<order::big, int_least32_t, 32> big_int32_buf_t; 116 typedef endian_buffer<order::big, int_least64_t, 40> big_int40_buf_t; 117 typedef endian_buffer<order::big, int_least64_t, 48> big_int48_buf_t; 118 typedef endian_buffer<order::big, int_least64_t, 56> big_int56_buf_t; 119 typedef endian_buffer<order::big, int_least64_t, 64> big_int64_buf_t; 120 121 // unaligned big endian unsigned integer buffers 122 typedef endian_buffer<order::big, uint_least8_t, 8> big_uint8_buf_t; 123 typedef endian_buffer<order::big, uint_least16_t, 16> big_uint16_buf_t; 124 typedef endian_buffer<order::big, uint_least32_t, 24> big_uint24_buf_t; 125 typedef endian_buffer<order::big, uint_least32_t, 32> big_uint32_buf_t; 126 typedef endian_buffer<order::big, uint_least64_t, 40> big_uint40_buf_t; 127 typedef endian_buffer<order::big, uint_least64_t, 48> big_uint48_buf_t; 128 typedef endian_buffer<order::big, uint_least64_t, 56> big_uint56_buf_t; 129 typedef endian_buffer<order::big, uint_least64_t, 64> big_uint64_buf_t; 130 131 // unaligned little endian signed integer buffers 132 typedef endian_buffer<order::little, int_least8_t, 8> little_int8_buf_t; 133 typedef endian_buffer<order::little, int_least16_t, 16> little_int16_buf_t; 134 typedef endian_buffer<order::little, int_least32_t, 24> little_int24_buf_t; 135 typedef endian_buffer<order::little, int_least32_t, 32> little_int32_buf_t; 136 typedef endian_buffer<order::little, int_least64_t, 40> little_int40_buf_t; 137 typedef endian_buffer<order::little, int_least64_t, 48> little_int48_buf_t; 138 typedef endian_buffer<order::little, int_least64_t, 56> little_int56_buf_t; 139 typedef endian_buffer<order::little, int_least64_t, 64> little_int64_buf_t; 140 141 // unaligned little endian unsigned integer buffers 142 typedef endian_buffer<order::little, uint_least8_t, 8> little_uint8_buf_t; 143 typedef endian_buffer<order::little, uint_least16_t, 16> little_uint16_buf_t; 144 typedef endian_buffer<order::little, uint_least32_t, 24> little_uint24_buf_t; 145 typedef endian_buffer<order::little, uint_least32_t, 32> little_uint32_buf_t; 146 typedef endian_buffer<order::little, uint_least64_t, 40> little_uint40_buf_t; 147 typedef endian_buffer<order::little, uint_least64_t, 48> little_uint48_buf_t; 148 typedef endian_buffer<order::little, uint_least64_t, 56> little_uint56_buf_t; 149 typedef endian_buffer<order::little, uint_least64_t, 64> little_uint64_buf_t; 150 151 // unaligned native endian signed integer buffers 152 typedef endian_buffer<order::native, int_least8_t, 8> native_int8_buf_t; 153 typedef endian_buffer<order::native, int_least16_t, 16> native_int16_buf_t; 154 typedef endian_buffer<order::native, int_least32_t, 24> native_int24_buf_t; 155 typedef endian_buffer<order::native, int_least32_t, 32> native_int32_buf_t; 156 typedef endian_buffer<order::native, int_least64_t, 40> native_int40_buf_t; 157 typedef endian_buffer<order::native, int_least64_t, 48> native_int48_buf_t; 158 typedef endian_buffer<order::native, int_least64_t, 56> native_int56_buf_t; 159 typedef endian_buffer<order::native, int_least64_t, 64> native_int64_buf_t; 160 161 // unaligned native endian unsigned integer buffers 162 typedef endian_buffer<order::native, uint_least8_t, 8> native_uint8_buf_t; 163 typedef endian_buffer<order::native, uint_least16_t, 16> native_uint16_buf_t; 164 typedef endian_buffer<order::native, uint_least32_t, 24> native_uint24_buf_t; 165 typedef endian_buffer<order::native, uint_least32_t, 32> native_uint32_buf_t; 166 typedef endian_buffer<order::native, uint_least64_t, 40> native_uint40_buf_t; 167 typedef endian_buffer<order::native, uint_least64_t, 48> native_uint48_buf_t; 168 typedef endian_buffer<order::native, uint_least64_t, 56> native_uint56_buf_t; 169 typedef endian_buffer<order::native, uint_least64_t, 64> native_uint64_buf_t; 170 171 // unaligned floating point buffers 172 typedef endian_buffer<order::big, float, 32, align::no> big_float32_buf_t; 173 typedef endian_buffer<order::big, double, 64, align::no> big_float64_buf_t; 174 typedef endian_buffer<order::little, float, 32, align::no> little_float32_buf_t; 175 typedef endian_buffer<order::little, double, 64, align::no> little_float64_buf_t; 176 typedef endian_buffer<order::native, float, 32, align::no> native_float32_buf_t; 177 typedef endian_buffer<order::native, double, 64, align::no> native_float64_buf_t; 178 179 // Stream inserter 180 template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T, 181 std::size_t n_bits, BOOST_SCOPED_ENUM(align) A> 182 std::basic_ostream<charT, traits>& operator <<(std::basic_ostream<charT,traits> & os,const endian_buffer<Order,T,n_bits,A> & x)183 operator<<(std::basic_ostream<charT, traits>& os, 184 const endian_buffer<Order, T, n_bits, A>& x) 185 { 186 return os << x.value(); 187 } 188 189 // Stream extractor 190 template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T, 191 std::size_t n_bits, BOOST_SCOPED_ENUM(align) A> 192 std::basic_istream<charT, traits>& operator >>(std::basic_istream<charT,traits> & is,endian_buffer<Order,T,n_bits,A> & x)193 operator>>(std::basic_istream<charT, traits>& is, 194 endian_buffer<Order, T, n_bits, A>& x) 195 { 196 T i; 197 if (is >> i) 198 x = i; 199 return is; 200 } 201 202 //---------------------------------- end synopsis ------------------------------------// 203 204 // endian_buffer class template specializations --------------------------------------// 205 206 // Specializations that represent unaligned bytes. 207 // Taking an integer type as a parameter provides a nice way to pass both 208 // the size and signedness of the desired integer and get the appropriate 209 // corresponding integer type for the interface. 210 211 // Q: Should endian_buffer supply "value_type operator value_type() const noexcept"? 212 // A: No. The rationale for endian_buffers is to prevent high-cost hidden 213 // conversions. If an implicit conversion operator is supplied, hidden conversions 214 // can occur. 215 216 // unaligned endian_buffer specialization 217 218 template< BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits > 219 class endian_buffer<Order, T, n_bits, align::no> 220 { 221 #ifdef BOOST_ENDIAN_NO_CTORS 222 public: 223 #endif 224 225 BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); 226 227 unsigned char value_[ n_bits / 8 ]; 228 229 public: 230 231 typedef T value_type; 232 233 #ifndef BOOST_ENDIAN_NO_CTORS 234 endian_buffer()235 endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT 236 237 explicit endian_buffer( T val ) BOOST_NOEXCEPT 238 { 239 boost::endian::endian_store<T, n_bits / 8, Order>( value_, val ); 240 } 241 242 #endif 243 operator =(T val)244 endian_buffer& operator=( T val ) BOOST_NOEXCEPT 245 { 246 boost::endian::endian_store<T, n_bits / 8, Order>( value_, val ); 247 return *this; 248 } 249 value() const250 value_type value() const BOOST_NOEXCEPT 251 { 252 return boost::endian::endian_load<T, n_bits / 8, Order>( value_ ); 253 } 254 data() const255 unsigned char const * data() const BOOST_NOEXCEPT 256 { 257 return value_; 258 } 259 data()260 unsigned char * data() BOOST_NOEXCEPT 261 { 262 return value_; 263 } 264 }; 265 266 // aligned specializations; only n_bits == 16/32/64 supported 267 268 // aligned endian_buffer specialization 269 270 template< BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits > 271 class endian_buffer<Order, T, n_bits, align::yes> 272 { 273 private: 274 275 BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); 276 BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); 277 278 union 279 { 280 unsigned char value_[ n_bits / 8 ]; 281 T align_; 282 }; 283 284 public: 285 286 typedef T value_type; 287 288 #ifndef BOOST_ENDIAN_NO_CTORS 289 endian_buffer()290 endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT 291 292 explicit endian_buffer( T val ) BOOST_NOEXCEPT 293 { 294 boost::endian::endian_store<T, n_bits / 8, Order>( value_, val ); 295 } 296 297 #endif 298 operator =(T val)299 endian_buffer& operator=( T val ) BOOST_NOEXCEPT 300 { 301 boost::endian::endian_store<T, n_bits / 8, Order>( value_, val ); 302 return *this; 303 } 304 value() const305 value_type value() const BOOST_NOEXCEPT 306 { 307 return boost::endian::endian_load<T, n_bits / 8, Order>( value_ ); 308 } 309 data() const310 unsigned char const * data() const BOOST_NOEXCEPT 311 { 312 return value_; 313 } 314 data()315 unsigned char * data() BOOST_NOEXCEPT 316 { 317 return value_; 318 } 319 }; 320 321 // aligned native endian_buffer specialization 322 323 template< class T, std::size_t n_bits > 324 class endian_buffer<order::native, T, n_bits, align::yes> 325 { 326 private: 327 328 BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); 329 BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); 330 331 T value_; 332 333 public: 334 335 typedef T value_type; 336 337 #ifndef BOOST_ENDIAN_NO_CTORS 338 endian_buffer()339 endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT 340 341 explicit endian_buffer( T val ) BOOST_NOEXCEPT: value_( val ) 342 { 343 } 344 345 #endif 346 operator =(T val)347 endian_buffer& operator=( T val ) BOOST_NOEXCEPT 348 { 349 value_ = val; 350 return *this; 351 } 352 value() const353 value_type value() const BOOST_NOEXCEPT 354 { 355 return value_; 356 } 357 data() const358 unsigned char const * data() const BOOST_NOEXCEPT 359 { 360 return reinterpret_cast< unsigned char const* >( &value_ ); 361 } 362 data()363 unsigned char * data() BOOST_NOEXCEPT 364 { 365 return reinterpret_cast< unsigned char* >( &value_ ); 366 } 367 }; 368 369 } // namespace endian 370 } // namespace boost 371 372 #if defined(BOOST_BORLANDC) || defined(BOOST_CODEGEARC) 373 # pragma pack(pop) 374 #endif 375 376 #if defined(_MSC_VER) 377 # pragma warning(pop) 378 #endif 379 380 #endif // BOOST_ENDIAN_BUFFERS_HPP 381