ceph/src/boost/boost/endian/buffers.hpp

   1 //  boost/endian/buffers.hpp  ----------------------------------------------------------//
   2
   3 //  (C) Copyright Darin Adler 2000
   4 //  (C) Copyright Beman Dawes 2006, 2009, 2014
   5
   6 //  Distributed under the Boost Software License, Version 1.0.
   7 //  See http://www.boost.org/LICENSE_1_0.txt
   8
   9 //  See library home page at http://www.boost.org/libs/endian
  10
  11 //--------------------------------------------------------------------------------------//
  12
  13 //  Original design developed by Darin Adler based on classes developed by Mark
  14 //  Borgerding. Four original class templates were combined into a single endian
  15 //  class template by Beman Dawes, who also added the unrolled_byte_loops sign
  16 //  partial specialization to correctly extend the sign when cover integer size
  17 //  differs from endian representation size.
  18
  19 // TODO: When a compiler supporting constexpr becomes available, try possible uses.
  20
  21 #ifndef BOOST_ENDIAN_BUFFERS_HPP
  22 #define BOOST_ENDIAN_BUFFERS_HPP
  23
  24 #if defined(_MSC_VER)
  25 # pragma warning(push)
  26 # pragma warning(disable:4365)  // conversion ... signed/unsigned mismatch
  27 #endif
  28
  29 #ifdef BOOST_ENDIAN_LOG
  30 # include <iostream>
  31 #endif
  32
  33 #if defined(__BORLANDC__) || defined( __CODEGEARC__)
  34 # pragma pack(push, 1)
  35 #endif
  36
  37 #include <boost/config.hpp>
  38 #include <boost/predef/detail/endian_compat.h>
  39 #include <boost/endian/conversion.hpp>
  40 #include <boost/type_traits/is_signed.hpp>
  41 #include <boost/cstdint.hpp>
  42 #include <boost/static_assert.hpp>
  43 #include <boost/core/scoped_enum.hpp>
  44 #include <iosfwd>
  45 #include <climits>
  46
  47 # if CHAR_BIT != 8
  48 #   error Platforms with CHAR_BIT != 8 are not supported
  49 # endif
  50
  51 # ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
  52 #   define BOOST_ENDIAN_DEFAULT_CONSTRUCT {}          // C++03
  53 # else
  54 #   define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default;  // C++0x
  55 # endif
  56
  57 # if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS)
  58 #   define BOOST_ENDIAN_NO_CTORS
  59 # endif
  60
  61 //----------------------------------  synopsis  ----------------------------------------//
  62
  63 namespace boost
  64 {
  65 namespace endian
  66 {
  67
  68   BOOST_SCOPED_ENUM_START(align)
  69   {no, yes
  70 #   ifdef BOOST_ENDIAN_DEPRECATED_NAMES
  71       , unaligned = no, aligned = yes
  72 #   endif
  73   }; BOOST_SCOPED_ENUM_END
  74
  75   template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
  76     BOOST_SCOPED_ENUM(align) A = align::no>
  77       class endian_buffer;
  78
  79   // aligned big endian signed integer buffers
  80   typedef endian_buffer<order::big, int8_t, 8, align::yes>       big_int8_buf_at;
  81   typedef endian_buffer<order::big, int16_t, 16, align::yes>     big_int16_buf_at;
  82   typedef endian_buffer<order::big, int32_t, 32, align::yes>     big_int32_buf_at;
  83   typedef endian_buffer<order::big, int64_t, 64, align::yes>     big_int64_buf_at;
  84
  85   // aligned big endian unsigned integer buffers
  86   typedef endian_buffer<order::big, uint8_t, 8, align::yes>      big_uint8_buf_at;
  87   typedef endian_buffer<order::big, uint16_t, 16, align::yes>    big_uint16_buf_at;
  88   typedef endian_buffer<order::big, uint32_t, 32, align::yes>    big_uint32_buf_at;
  89   typedef endian_buffer<order::big, uint64_t, 64, align::yes>    big_uint64_buf_at;
  90
  91   // aligned little endian signed integer buffers
  92   typedef endian_buffer<order::little, int8_t, 8, align::yes>    little_int8_buf_at;
  93   typedef endian_buffer<order::little, int16_t, 16, align::yes>  little_int16_buf_at;
  94   typedef endian_buffer<order::little, int32_t, 32, align::yes>  little_int32_buf_at;
  95   typedef endian_buffer<order::little, int64_t, 64, align::yes>  little_int64_buf_at;
  96
  97   // aligned little endian unsigned integer buffers
  98   typedef endian_buffer<order::little, uint8_t, 8, align::yes>   little_uint8_buf_at;
  99   typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_at;
 100   typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_at;
 101   typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_at;
 102
 103   // aligned native endian typedefs are not provided because
 104   // <cstdint> types are superior for this use case
 105
 106   // unaligned big endian signed integer buffers
 107   typedef endian_buffer<order::big, int_least8_t, 8>        big_int8_buf_t;
 108   typedef endian_buffer<order::big, int_least16_t, 16>      big_int16_buf_t;
 109   typedef endian_buffer<order::big, int_least32_t, 24>      big_int24_buf_t;
 110   typedef endian_buffer<order::big, int_least32_t, 32>      big_int32_buf_t;
 111   typedef endian_buffer<order::big, int_least64_t, 40>      big_int40_buf_t;
 112   typedef endian_buffer<order::big, int_least64_t, 48>      big_int48_buf_t;
 113   typedef endian_buffer<order::big, int_least64_t, 56>      big_int56_buf_t;
 114   typedef endian_buffer<order::big, int_least64_t, 64>      big_int64_buf_t;
 115
 116   // unaligned big endian unsigned integer buffers
 117   typedef endian_buffer<order::big, uint_least8_t, 8>       big_uint8_buf_t;
 118   typedef endian_buffer<order::big, uint_least16_t, 16>     big_uint16_buf_t;
 119   typedef endian_buffer<order::big, uint_least32_t, 24>     big_uint24_buf_t;
 120   typedef endian_buffer<order::big, uint_least32_t, 32>     big_uint32_buf_t;
 121   typedef endian_buffer<order::big, uint_least64_t, 40>     big_uint40_buf_t;
 122   typedef endian_buffer<order::big, uint_least64_t, 48>     big_uint48_buf_t;
 123   typedef endian_buffer<order::big, uint_least64_t, 56>     big_uint56_buf_t;
 124   typedef endian_buffer<order::big, uint_least64_t, 64>     big_uint64_buf_t;
 125
 126   // unaligned little endian signed integer buffers
 127   typedef endian_buffer<order::little, int_least8_t, 8>     little_int8_buf_t;
 128   typedef endian_buffer<order::little, int_least16_t, 16>   little_int16_buf_t;
 129   typedef endian_buffer<order::little, int_least32_t, 24>   little_int24_buf_t;
 130   typedef endian_buffer<order::little, int_least32_t, 32>   little_int32_buf_t;
 131   typedef endian_buffer<order::little, int_least64_t, 40>   little_int40_buf_t;
 132   typedef endian_buffer<order::little, int_least64_t, 48>   little_int48_buf_t;
 133   typedef endian_buffer<order::little, int_least64_t, 56>   little_int56_buf_t;
 134   typedef endian_buffer<order::little, int_least64_t, 64>   little_int64_buf_t;
 135
 136   // unaligned little endian unsigned integer buffers
 137   typedef endian_buffer<order::little, uint_least8_t, 8>    little_uint8_buf_t;
 138   typedef endian_buffer<order::little, uint_least16_t, 16>  little_uint16_buf_t;
 139   typedef endian_buffer<order::little, uint_least32_t, 24>  little_uint24_buf_t;
 140   typedef endian_buffer<order::little, uint_least32_t, 32>  little_uint32_buf_t;
 141   typedef endian_buffer<order::little, uint_least64_t, 40>  little_uint40_buf_t;
 142   typedef endian_buffer<order::little, uint_least64_t, 48>  little_uint48_buf_t;
 143   typedef endian_buffer<order::little, uint_least64_t, 56>  little_uint56_buf_t;
 144   typedef endian_buffer<order::little, uint_least64_t, 64>  little_uint64_buf_t;
 145
 146 # ifdef BOOST_BIG_ENDIAN
 147   // unaligned native endian signed integer buffers
 148   typedef big_int8_buf_t   native_int8_buf_t;
 149   typedef big_int16_buf_t  native_int16_buf_t;
 150   typedef big_int24_buf_t  native_int24_buf_t;
 151   typedef big_int32_buf_t  native_int32_buf_t;
 152   typedef big_int40_buf_t  native_int40_buf_t;
 153   typedef big_int48_buf_t  native_int48_buf_t;
 154   typedef big_int56_buf_t  native_int56_buf_t;
 155   typedef big_int64_buf_t  native_int64_buf_t;
 156
 157   // unaligned native endian unsigned integer buffers
 158   typedef big_uint8_buf_t   native_uint8_buf_t;
 159   typedef big_uint16_buf_t  native_uint16_buf_t;
 160   typedef big_uint24_buf_t  native_uint24_buf_t;
 161   typedef big_uint32_buf_t  native_uint32_buf_t;
 162   typedef big_uint40_buf_t  native_uint40_buf_t;
 163   typedef big_uint48_buf_t  native_uint48_buf_t;
 164   typedef big_uint56_buf_t  native_uint56_buf_t;
 165   typedef big_uint64_buf_t  native_uint64_buf_t;
 166 # else
 167   // unaligned native endian signed integer buffers
 168   typedef little_int8_buf_t   native_int8_buf_t;
 169   typedef little_int16_buf_t  native_int16_buf_t;
 170   typedef little_int24_buf_t  native_int24_buf_t;
 171   typedef little_int32_buf_t  native_int32_buf_t;
 172   typedef little_int40_buf_t  native_int40_buf_t;
 173   typedef little_int48_buf_t  native_int48_buf_t;
 174   typedef little_int56_buf_t  native_int56_buf_t;
 175   typedef little_int64_buf_t  native_int64_buf_t;
 176
 177   // unaligned native endian unsigned integer buffers
 178   typedef little_uint8_buf_t   native_uint8_buf_t;
 179   typedef little_uint16_buf_t  native_uint16_buf_t;
 180   typedef little_uint24_buf_t  native_uint24_buf_t;
 181   typedef little_uint32_buf_t  native_uint32_buf_t;
 182   typedef little_uint40_buf_t  native_uint40_buf_t;
 183   typedef little_uint48_buf_t  native_uint48_buf_t;
 184   typedef little_uint56_buf_t  native_uint56_buf_t;
 185   typedef little_uint64_buf_t  native_uint64_buf_t;
 186 # endif
 187
 188   // Stream inserter
 189   template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
 190     std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
 191   std::basic_ostream<charT, traits>&
 192     operator<<(std::basic_ostream<charT, traits>& os,
 193       const endian_buffer<Order, T, n_bits, A>& x)
 194   {
 195     return os << x.value();
 196   }
 197
 198   // Stream extractor
 199   template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
 200     std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
 201   std::basic_istream<charT, traits>&
 202     operator>>(std::basic_istream<charT, traits>& is,
 203       endian_buffer<Order, T, n_bits, A>& x)
 204   {
 205     T i;
 206     if (is >> i)
 207       x = i;
 208     return is;
 209   }
 210
 211 //----------------------------------  end synopsis  ------------------------------------//
 212
 213   namespace detail
 214   {
 215
 216     // Unrolled loops for loading and storing streams of bytes.
 217
 218     template <typename T, std::size_t n_bytes,
 219       bool sign=boost::is_signed<T>::value >
 220     struct unrolled_byte_loops
 221     {
 222       typedef unrolled_byte_loops<T, n_bytes - 1, sign> next;
 223
 224       static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
 225         { return static_cast<T>(*(bytes - 1) | (next::load_big(bytes - 1) << 8)); }
 226       static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
 227         { return static_cast<T>(*bytes | (next::load_little(bytes + 1) << 8)); }
 228
 229       static void store_big(char* bytes, T value) BOOST_NOEXCEPT
 230         {
 231           *(bytes - 1) = static_cast<char>(value);
 232           next::store_big(bytes - 1, static_cast<T>(value >> 8));
 233         }
 234       static void store_little(char* bytes, T value) BOOST_NOEXCEPT
 235         {
 236           *bytes = static_cast<char>(value);
 237           next::store_little(bytes + 1, static_cast<T>(value >> 8));
 238         }
 239     };
 240
 241     template <typename T>
 242     struct unrolled_byte_loops<T, 1, false>
 243     {
 244       static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
 245         { return *(bytes - 1); }
 246       static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
 247         { return *bytes; }
 248       static void store_big(char* bytes, T value) BOOST_NOEXCEPT
 249         { *(bytes - 1) = static_cast<char>(value); }
 250       static void store_little(char* bytes, T value) BOOST_NOEXCEPT
 251         { *bytes = static_cast<char>(value); }
 252
 253     };
 254
 255     template <typename T>
 256     struct unrolled_byte_loops<T, 1, true>
 257     {
 258       static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
 259         { return *reinterpret_cast<const signed char*>(bytes - 1); }
 260       static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
 261         { return *reinterpret_cast<const signed char*>(bytes); }
 262       static void store_big(char* bytes, T value)  BOOST_NOEXCEPT
 263         { *(bytes - 1) = static_cast<char>(value); }
 264       static void store_little(char* bytes, T value) BOOST_NOEXCEPT
 265         { *bytes = static_cast<char>(value); }
 266     };
 267
 268     template <typename T, std::size_t n_bytes>
 269     inline
 270     T load_big_endian(const void* bytes) BOOST_NOEXCEPT
 271     {
 272       return unrolled_byte_loops<T, n_bytes>::load_big
 273         (static_cast<const unsigned char*>(bytes) + n_bytes);
 274     }
 275
 276     template <typename T, std::size_t n_bytes>
 277     inline
 278     T load_little_endian(const void* bytes) BOOST_NOEXCEPT
 279     {
 280 #   if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
 281       // On x86 (which is little endian), unaligned loads are permitted
 282       if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
 283                                  // test and generate code only for the applicable return
 284                                  // case since sizeof(T) and n_bytes are known at compile
 285                                  // time.
 286       {
 287         return *reinterpret_cast<T const *>(bytes);
 288       }
 289 #   endif
 290       return unrolled_byte_loops<T, n_bytes>::load_little
 291         (static_cast<const unsigned char*>(bytes));
 292     }
 293
 294     template <typename T, std::size_t n_bytes>
 295     inline
 296     void store_big_endian(void* bytes, T value) BOOST_NOEXCEPT
 297     {
 298       unrolled_byte_loops<T, n_bytes>::store_big
 299         (static_cast<char*>(bytes) + n_bytes, value);
 300     }
 301
 302     template <typename T, std::size_t n_bytes>
 303     inline
 304     void store_little_endian(void* bytes, T value) BOOST_NOEXCEPT
 305     {
 306 #     if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
 307       // On x86 (which is little endian), unaligned stores are permitted
 308       if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
 309                                  // test and generate code only for the applicable return
 310                                  // case since sizeof(T) and n_bytes are known at compile
 311                                  // time.
 312       {
 313         *reinterpret_cast<T *>(bytes) = value;
 314         return;
 315       }
 316 #     endif
 317       unrolled_byte_loops<T, n_bytes>::store_little
 318         (static_cast<char*>(bytes), value);
 319     }
 320
 321   } // namespace detail
 322
 323 # ifdef BOOST_ENDIAN_LOG
 324     bool endian_log(true);
 325 # endif
 326
 327 //  endian_buffer class template specializations  --------------------------------------//
 328
 329     //  Specializations that represent unaligned bytes.
 330     //  Taking an integer type as a parameter provides a nice way to pass both
 331     //  the size and signedness of the desired integer and get the appropriate
 332     //  corresponding integer type for the interface.
 333
 334     // Q: Should endian_buffer supply "value_type operator value_type() const noexcept"?
 335     // A: No. The rationale for endian_buffers is to prevent high-cost hidden
 336     //    conversions. If an implicit conversion operator is supplied, hidden conversions
 337     //    can occur.
 338
 339     //  unaligned big endian_buffer specialization
 340     template <typename T, std::size_t n_bits>
 341     class endian_buffer< order::big, T, n_bits, align::no >
 342     {
 343         BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
 344       public:
 345         typedef T value_type;
 346 #     ifndef BOOST_ENDIAN_NO_CTORS
 347         endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
 348         explicit endian_buffer(T val) BOOST_NOEXCEPT
 349         {
 350 #       ifdef BOOST_ENDIAN_LOG
 351           if ( endian_log )
 352             std::cout << "big, unaligned, "
 353               << n_bits << "-bits, construct(" << val << ")\n";
 354 #       endif
 355           detail::store_big_endian<T, n_bits/8>(m_value, val);
 356         }
 357 #     endif
 358         endian_buffer & operator=(T val) BOOST_NOEXCEPT
 359         {
 360 #       ifdef BOOST_ENDIAN_LOG
 361           if (endian_log)
 362             std::cout << "big, unaligned, " << n_bits << "-bits, assign(" << val << ")\n";
 363 #       endif
 364           detail::store_big_endian<T, n_bits/8>(m_value, val);
 365           return *this;
 366         }
 367         value_type value() const BOOST_NOEXCEPT
 368         {
 369 #       ifdef BOOST_ENDIAN_LOG
 370           if ( endian_log )
 371             std::cout << "big, unaligned, " << n_bits << "-bits, convert("
 372               << detail::load_big_endian<T, n_bits/8>(m_value) << ")\n";
 373 #       endif
 374           return detail::load_big_endian<T, n_bits/8>(m_value);
 375         }
 376         const char* data() const BOOST_NOEXCEPT  { return m_value; }
 377       protected:
 378         char m_value[n_bits/8];
 379     };
 380
 381     //  unaligned little endian_buffer specialization
 382     template <typename T, std::size_t n_bits>
 383     class endian_buffer< order::little, T, n_bits, align::no >
 384     {
 385         BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
 386       public:
 387         typedef T value_type;
 388 #     ifndef BOOST_ENDIAN_NO_CTORS
 389         endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
 390         explicit endian_buffer(T val) BOOST_NOEXCEPT
 391         {
 392 #       ifdef BOOST_ENDIAN_LOG
 393           if ( endian_log )
 394             std::cout << "little, unaligned, " << n_bits << "-bits, construct("
 395               << val << ")\n";
 396 #       endif
 397           detail::store_little_endian<T, n_bits/8>(m_value, val);
 398         }
 399 #     endif
 400         endian_buffer & operator=(T val) BOOST_NOEXCEPT
 401           { detail::store_little_endian<T, n_bits/8>(m_value, val); return *this; }
 402         value_type value() const BOOST_NOEXCEPT
 403         {
 404 #       ifdef BOOST_ENDIAN_LOG
 405           if ( endian_log )
 406             std::cout << "little, unaligned, " << n_bits << "-bits, convert("
 407               << detail::load_little_endian<T, n_bits/8>(m_value) << ")\n";
 408 #       endif
 409           return detail::load_little_endian<T, n_bits/8>(m_value);
 410         }
 411         const char* data() const BOOST_NOEXCEPT  { return m_value; }
 412       protected:
 413         char m_value[n_bits/8];
 414     };
 415
 416   //  align::yes specializations; only n_bits == 16/32/64 supported
 417
 418     //  aligned big endian_buffer specialization
 419     template <typename T, std::size_t n_bits>
 420     class endian_buffer<order::big, T, n_bits, align::yes>
 421     {
 422         BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
 423         BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
 424       public:
 425         typedef T value_type;
 426 #     ifndef BOOST_ENDIAN_NO_CTORS
 427         endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
 428         explicit endian_buffer(T val) BOOST_NOEXCEPT
 429         {
 430 #       ifdef BOOST_ENDIAN_LOG
 431           if ( endian_log )
 432             std::cout << "big, aligned, " << n_bits
 433               << "-bits, construct(" << val << ")\n";
 434 #       endif
 435           m_value = ::boost::endian::native_to_big(val);
 436         }
 437
 438 #     endif
 439         endian_buffer& operator=(T val) BOOST_NOEXCEPT
 440         {
 441           m_value = ::boost::endian::native_to_big(val);
 442           return *this;
 443         }
 444         //operator value_type() const BOOST_NOEXCEPT
 445         //{
 446         //  return ::boost::endian::big_to_native(m_value);
 447         //}
 448         value_type value() const BOOST_NOEXCEPT
 449         {
 450 #       ifdef BOOST_ENDIAN_LOG
 451           if ( endian_log )
 452             std::cout << "big, aligned, " << n_bits << "-bits, convert("
 453               << ::boost::endian::big_to_native(m_value) << ")\n";
 454 #       endif
 455           return ::boost::endian::big_to_native(m_value);
 456         }
 457         const char* data() const BOOST_NOEXCEPT
 458           {return reinterpret_cast<const char*>(&m_value);}
 459       protected:
 460         T m_value;
 461     };
 462
 463     //  aligned little endian_buffer specialization
 464     template <typename T, std::size_t n_bits>
 465     class endian_buffer<order::little, T, n_bits, align::yes>
 466     {
 467         BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
 468         BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
 469       public:
 470         typedef T value_type;
 471 #     ifndef BOOST_ENDIAN_NO_CTORS
 472         endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
 473         explicit endian_buffer(T val) BOOST_NOEXCEPT
 474         {
 475 #       ifdef BOOST_ENDIAN_LOG
 476           if ( endian_log )
 477             std::cout << "little, aligned, " << n_bits
 478               << "-bits, construct(" << val << ")\n";
 479 #       endif
 480           m_value = ::boost::endian::native_to_little(val);
 481         }
 482
 483 #     endif
 484         endian_buffer& operator=(T val) BOOST_NOEXCEPT
 485         {
 486           m_value = ::boost::endian::native_to_little(val);
 487           return *this;
 488         }
 489         value_type value() const BOOST_NOEXCEPT
 490         {
 491 #       ifdef BOOST_ENDIAN_LOG
 492           if ( endian_log )
 493             std::cout << "little, aligned, " << n_bits << "-bits, convert("
 494               << ::boost::endian::little_to_native(m_value) << ")\n";
 495 #       endif
 496           return ::boost::endian::little_to_native(m_value);
 497         }
 498         const char* data() const BOOST_NOEXCEPT
 499           {return reinterpret_cast<const char*>(&m_value);}
 500       protected:
 501         T m_value;
 502     };
 503
 504 } // namespace endian
 505 } // namespace boost
 506
 507 #if defined(__BORLANDC__) || defined( __CODEGEARC__)
 508 # pragma pack(pop)
 509 #endif
 510
 511 #if defined(_MSC_VER)
 512 # pragma warning(pop)
 513 #endif
 514
 515 #endif // BOOST_ENDIAN_BUFFERS_HPP