Chris@102: //  boost/endian/buffers.hpp  ----------------------------------------------------------//
Chris@102: 
Chris@102: //  (C) Copyright Darin Adler 2000
Chris@102: //  (C) Copyright Beman Dawes 2006, 2009, 2014
Chris@102: 
Chris@102: //  Distributed under the Boost Software License, Version 1.0.
Chris@102: //  See http://www.boost.org/LICENSE_1_0.txt
Chris@102: 
Chris@102: //  See library home page at http://www.boost.org/libs/endian
Chris@102: 
Chris@102: //--------------------------------------------------------------------------------------//
Chris@102: 
Chris@102: //  Original design developed by Darin Adler based on classes developed by Mark
Chris@102: //  Borgerding. Four original class templates were combined into a single endian
Chris@102: //  class template by Beman Dawes, who also added the unrolled_byte_loops sign
Chris@102: //  partial specialization to correctly extend the sign when cover integer size
Chris@102: //  differs from endian representation size.
Chris@102: 
Chris@102: // TODO: When a compiler supporting constexpr becomes available, try possible uses.
Chris@102: 
Chris@102: #ifndef BOOST_ENDIAN_BUFFERS_HPP
Chris@102: #define BOOST_ENDIAN_BUFFERS_HPP
Chris@102: 
Chris@102: #if defined(_MSC_VER)  
Chris@102: # pragma warning(push)  
Chris@102: # pragma warning(disable:4365)  // conversion ... signed/unsigned mismatch
Chris@102: #endif
Chris@102: 
Chris@102: #ifdef BOOST_ENDIAN_LOG
Chris@102: # include <iostream>
Chris@102: #endif
Chris@102: 
Chris@102: #if defined(__BORLANDC__) || defined( __CODEGEARC__)
Chris@102: # pragma pack(push, 1)
Chris@102: #endif
Chris@102: 
Chris@102: #include <boost/config.hpp>
Chris@102: #include <boost/predef/detail/endian_compat.h>
Chris@102: #include <boost/endian/conversion.hpp>
Chris@102: #include <boost/type_traits/is_signed.hpp>
Chris@102: #include <boost/cstdint.hpp>
Chris@102: #include <boost/static_assert.hpp>
Chris@102: #include <boost/core/scoped_enum.hpp>
Chris@102: #include <iosfwd>
Chris@102: #include <climits>
Chris@102: 
Chris@102: # if CHAR_BIT != 8
Chris@102: #   error Platforms with CHAR_BIT != 8 are not supported
Chris@102: # endif
Chris@102: 
Chris@102: # ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
Chris@102: #   define BOOST_ENDIAN_DEFAULT_CONSTRUCT {}          // C++03
Chris@102: # else
Chris@102: #   define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default;  // C++0x
Chris@102: # endif
Chris@102: 
Chris@102: # if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS)
Chris@102: #   define BOOST_ENDIAN_NO_CTORS
Chris@102: # endif
Chris@102: 
Chris@102: //----------------------------------  synopsis  ----------------------------------------//
Chris@102: 
Chris@102: namespace boost
Chris@102: {
Chris@102: namespace endian
Chris@102: {
Chris@102: 
Chris@102:   BOOST_SCOPED_ENUM_START(align)
Chris@102:   {no, yes
Chris@102: #   ifdef BOOST_ENDIAN_DEPRECATED_NAMES
Chris@102:       , unaligned = no, aligned = yes
Chris@102: #   endif
Chris@102:   }; BOOST_SCOPED_ENUM_END
Chris@102: 
Chris@102:   template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits,
Chris@102:     BOOST_SCOPED_ENUM(align) A = align::no>
Chris@102:       class endian_buffer;
Chris@102: 
Chris@102:   // aligned big endian signed integer buffers
Chris@102:   typedef endian_buffer<order::big, int8_t, 8, align::yes>       big_int8_buf_at;
Chris@102:   typedef endian_buffer<order::big, int16_t, 16, align::yes>     big_int16_buf_at;
Chris@102:   typedef endian_buffer<order::big, int32_t, 32, align::yes>     big_int32_buf_at;
Chris@102:   typedef endian_buffer<order::big, int64_t, 64, align::yes>     big_int64_buf_at;
Chris@102: 
Chris@102:   // aligned big endian unsigned integer buffers
Chris@102:   typedef endian_buffer<order::big, uint8_t, 8, align::yes>      big_uint8_buf_at;
Chris@102:   typedef endian_buffer<order::big, uint16_t, 16, align::yes>    big_uint16_buf_at;
Chris@102:   typedef endian_buffer<order::big, uint32_t, 32, align::yes>    big_uint32_buf_at;
Chris@102:   typedef endian_buffer<order::big, uint64_t, 64, align::yes>    big_uint64_buf_at;
Chris@102: 
Chris@102:   // aligned little endian signed integer buffers
Chris@102:   typedef endian_buffer<order::little, int8_t, 8, align::yes>    little_int8_buf_at;
Chris@102:   typedef endian_buffer<order::little, int16_t, 16, align::yes>  little_int16_buf_at;
Chris@102:   typedef endian_buffer<order::little, int32_t, 32, align::yes>  little_int32_buf_at;
Chris@102:   typedef endian_buffer<order::little, int64_t, 64, align::yes>  little_int64_buf_at;
Chris@102: 
Chris@102:   // aligned little endian unsigned integer buffers
Chris@102:   typedef endian_buffer<order::little, uint8_t, 8, align::yes>   little_uint8_buf_at;
Chris@102:   typedef endian_buffer<order::little, uint16_t, 16, align::yes> little_uint16_buf_at;
Chris@102:   typedef endian_buffer<order::little, uint32_t, 32, align::yes> little_uint32_buf_at;
Chris@102:   typedef endian_buffer<order::little, uint64_t, 64, align::yes> little_uint64_buf_at;
Chris@102: 
Chris@102:   // aligned native endian typedefs are not provided because
Chris@102:   // <cstdint> types are superior for this use case
Chris@102: 
Chris@102:   // unaligned big endian signed integer buffers
Chris@102:   typedef endian_buffer<order::big, int_least8_t, 8>        big_int8_buf_t;
Chris@102:   typedef endian_buffer<order::big, int_least16_t, 16>      big_int16_buf_t;
Chris@102:   typedef endian_buffer<order::big, int_least32_t, 24>      big_int24_buf_t;
Chris@102:   typedef endian_buffer<order::big, int_least32_t, 32>      big_int32_buf_t;
Chris@102:   typedef endian_buffer<order::big, int_least64_t, 40>      big_int40_buf_t;
Chris@102:   typedef endian_buffer<order::big, int_least64_t, 48>      big_int48_buf_t;
Chris@102:   typedef endian_buffer<order::big, int_least64_t, 56>      big_int56_buf_t;
Chris@102:   typedef endian_buffer<order::big, int_least64_t, 64>      big_int64_buf_t;
Chris@102: 
Chris@102:   // unaligned big endian unsigned integer buffers
Chris@102:   typedef endian_buffer<order::big, uint_least8_t, 8>       big_uint8_buf_t;
Chris@102:   typedef endian_buffer<order::big, uint_least16_t, 16>     big_uint16_buf_t;
Chris@102:   typedef endian_buffer<order::big, uint_least32_t, 24>     big_uint24_buf_t;
Chris@102:   typedef endian_buffer<order::big, uint_least32_t, 32>     big_uint32_buf_t;
Chris@102:   typedef endian_buffer<order::big, uint_least64_t, 40>     big_uint40_buf_t;
Chris@102:   typedef endian_buffer<order::big, uint_least64_t, 48>     big_uint48_buf_t;
Chris@102:   typedef endian_buffer<order::big, uint_least64_t, 56>     big_uint56_buf_t;
Chris@102:   typedef endian_buffer<order::big, uint_least64_t, 64>     big_uint64_buf_t;
Chris@102: 
Chris@102:   // unaligned little endian signed integer buffers
Chris@102:   typedef endian_buffer<order::little, int_least8_t, 8>     little_int8_buf_t;
Chris@102:   typedef endian_buffer<order::little, int_least16_t, 16>   little_int16_buf_t;
Chris@102:   typedef endian_buffer<order::little, int_least32_t, 24>   little_int24_buf_t;
Chris@102:   typedef endian_buffer<order::little, int_least32_t, 32>   little_int32_buf_t;
Chris@102:   typedef endian_buffer<order::little, int_least64_t, 40>   little_int40_buf_t;
Chris@102:   typedef endian_buffer<order::little, int_least64_t, 48>   little_int48_buf_t;
Chris@102:   typedef endian_buffer<order::little, int_least64_t, 56>   little_int56_buf_t;
Chris@102:   typedef endian_buffer<order::little, int_least64_t, 64>   little_int64_buf_t;
Chris@102: 
Chris@102:   // unaligned little endian unsigned integer buffers
Chris@102:   typedef endian_buffer<order::little, uint_least8_t, 8>    little_uint8_buf_t;
Chris@102:   typedef endian_buffer<order::little, uint_least16_t, 16>  little_uint16_buf_t;
Chris@102:   typedef endian_buffer<order::little, uint_least32_t, 24>  little_uint24_buf_t;
Chris@102:   typedef endian_buffer<order::little, uint_least32_t, 32>  little_uint32_buf_t;
Chris@102:   typedef endian_buffer<order::little, uint_least64_t, 40>  little_uint40_buf_t;
Chris@102:   typedef endian_buffer<order::little, uint_least64_t, 48>  little_uint48_buf_t;
Chris@102:   typedef endian_buffer<order::little, uint_least64_t, 56>  little_uint56_buf_t;
Chris@102:   typedef endian_buffer<order::little, uint_least64_t, 64>  little_uint64_buf_t;
Chris@102: 
Chris@102: # ifdef BOOST_BIG_ENDIAN
Chris@102:   // unaligned native endian signed integer buffers
Chris@102:   typedef big_int8_buf_t   native_int8_buf_t;
Chris@102:   typedef big_int16_buf_t  native_int16_buf_t;
Chris@102:   typedef big_int24_buf_t  native_int24_buf_t;
Chris@102:   typedef big_int32_buf_t  native_int32_buf_t;
Chris@102:   typedef big_int40_buf_t  native_int40_buf_t;
Chris@102:   typedef big_int48_buf_t  native_int48_buf_t;
Chris@102:   typedef big_int56_buf_t  native_int56_buf_t;
Chris@102:   typedef big_int64_buf_t  native_int64_buf_t;
Chris@102: 
Chris@102:   // unaligned native endian unsigned integer buffers
Chris@102:   typedef big_uint8_buf_t   native_uint8_buf_t;
Chris@102:   typedef big_uint16_buf_t  native_uint16_buf_t;
Chris@102:   typedef big_uint24_buf_t  native_uint24_buf_t;
Chris@102:   typedef big_uint32_buf_t  native_uint32_buf_t;
Chris@102:   typedef big_uint40_buf_t  native_uint40_buf_t;
Chris@102:   typedef big_uint48_buf_t  native_uint48_buf_t;
Chris@102:   typedef big_uint56_buf_t  native_uint56_buf_t;
Chris@102:   typedef big_uint64_buf_t  native_uint64_buf_t;
Chris@102: # else
Chris@102:   // unaligned native endian signed integer buffers
Chris@102:   typedef little_int8_buf_t   native_int8_buf_t;
Chris@102:   typedef little_int16_buf_t  native_int16_buf_t;
Chris@102:   typedef little_int24_buf_t  native_int24_buf_t;
Chris@102:   typedef little_int32_buf_t  native_int32_buf_t;
Chris@102:   typedef little_int40_buf_t  native_int40_buf_t;
Chris@102:   typedef little_int48_buf_t  native_int48_buf_t;
Chris@102:   typedef little_int56_buf_t  native_int56_buf_t;
Chris@102:   typedef little_int64_buf_t  native_int64_buf_t;
Chris@102: 
Chris@102:   // unaligned native endian unsigned integer buffers
Chris@102:   typedef little_uint8_buf_t   native_uint8_buf_t;
Chris@102:   typedef little_uint16_buf_t  native_uint16_buf_t;
Chris@102:   typedef little_uint24_buf_t  native_uint24_buf_t;
Chris@102:   typedef little_uint32_buf_t  native_uint32_buf_t;
Chris@102:   typedef little_uint40_buf_t  native_uint40_buf_t;
Chris@102:   typedef little_uint48_buf_t  native_uint48_buf_t;
Chris@102:   typedef little_uint56_buf_t  native_uint56_buf_t;
Chris@102:   typedef little_uint64_buf_t  native_uint64_buf_t;
Chris@102: # endif
Chris@102: 
Chris@102:   // Stream inserter
Chris@102:   template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
Chris@102:     std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
Chris@102:   std::basic_ostream<charT, traits>&
Chris@102:     operator<<(std::basic_ostream<charT, traits>& os,
Chris@102:       const endian_buffer<Order, T, n_bits, A>& x)
Chris@102:   {
Chris@102:     return os << x.value();
Chris@102:   }
Chris@102: 
Chris@102:   // Stream extractor 
Chris@102:   template <class charT, class traits, BOOST_SCOPED_ENUM(order) Order, class T,
Chris@102:     std::size_t n_bits, BOOST_SCOPED_ENUM(align) A>
Chris@102:   std::basic_istream<charT, traits>&
Chris@102:     operator>>(std::basic_istream<charT, traits>& is,
Chris@102:       endian_buffer<Order, T, n_bits, A>& x)
Chris@102:   {
Chris@102:     T i;
Chris@102:     if (is >> i)
Chris@102:       x = i;
Chris@102:     return is;
Chris@102:   }
Chris@102: 
Chris@102: //----------------------------------  end synopsis  ------------------------------------//
Chris@102: 
Chris@102:   namespace detail
Chris@102:   {
Chris@102: 
Chris@102:     // Unrolled loops for loading and storing streams of bytes.
Chris@102: 
Chris@102:     template <typename T, std::size_t n_bytes,
Chris@102:       bool sign=boost::is_signed<T>::value >
Chris@102:     struct unrolled_byte_loops
Chris@102:     {
Chris@102:       typedef unrolled_byte_loops<T, n_bytes - 1, sign> next;
Chris@102: 
Chris@102:       static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
Chris@102:         { return static_cast<T>(*(bytes - 1) | (next::load_big(bytes - 1) << 8)); }
Chris@102:       static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
Chris@102:         { return static_cast<T>(*bytes | (next::load_little(bytes + 1) << 8)); }
Chris@102: 
Chris@102:       static void store_big(char* bytes, T value) BOOST_NOEXCEPT
Chris@102:         {
Chris@102:           *(bytes - 1) = static_cast<char>(value);
Chris@102:           next::store_big(bytes - 1, static_cast<T>(value >> 8));
Chris@102:         }
Chris@102:       static void store_little(char* bytes, T value) BOOST_NOEXCEPT
Chris@102:         {
Chris@102:           *bytes = static_cast<char>(value);
Chris@102:           next::store_little(bytes + 1, static_cast<T>(value >> 8));
Chris@102:         }
Chris@102:     };
Chris@102: 
Chris@102:     template <typename T>
Chris@102:     struct unrolled_byte_loops<T, 1, false>
Chris@102:     {
Chris@102:       static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
Chris@102:         { return *(bytes - 1); }
Chris@102:       static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
Chris@102:         { return *bytes; }
Chris@102:       static void store_big(char* bytes, T value) BOOST_NOEXCEPT
Chris@102:         { *(bytes - 1) = static_cast<char>(value); }
Chris@102:       static void store_little(char* bytes, T value) BOOST_NOEXCEPT
Chris@102:         { *bytes = static_cast<char>(value); }
Chris@102: 
Chris@102:     };
Chris@102: 
Chris@102:     template <typename T>
Chris@102:     struct unrolled_byte_loops<T, 1, true>
Chris@102:     {
Chris@102:       static T load_big(const unsigned char* bytes) BOOST_NOEXCEPT
Chris@102:         { return *reinterpret_cast<const signed char*>(bytes - 1); }
Chris@102:       static T load_little(const unsigned char* bytes) BOOST_NOEXCEPT
Chris@102:         { return *reinterpret_cast<const signed char*>(bytes); }
Chris@102:       static void store_big(char* bytes, T value)  BOOST_NOEXCEPT
Chris@102:         { *(bytes - 1) = static_cast<char>(value); }
Chris@102:       static void store_little(char* bytes, T value) BOOST_NOEXCEPT
Chris@102:         { *bytes = static_cast<char>(value); }
Chris@102:     };
Chris@102: 
Chris@102:     template <typename T, std::size_t n_bytes>
Chris@102:     inline
Chris@102:     T load_big_endian(const void* bytes) BOOST_NOEXCEPT
Chris@102:     {
Chris@102:       return unrolled_byte_loops<T, n_bytes>::load_big
Chris@102:         (static_cast<const unsigned char*>(bytes) + n_bytes);
Chris@102:     }
Chris@102: 
Chris@102:     template <typename T, std::size_t n_bytes>
Chris@102:     inline
Chris@102:     T load_little_endian(const void* bytes) BOOST_NOEXCEPT
Chris@102:     {
Chris@102: #   if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
Chris@102:       // On x86 (which is little endian), unaligned loads are permitted
Chris@102:       if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
Chris@102:                                  // test and generate code only for the applicable return
Chris@102:                                  // case since sizeof(T) and n_bytes are known at compile
Chris@102:                                  // time.
Chris@102:       {
Chris@102:         return *reinterpret_cast<T const *>(bytes);
Chris@102:       }
Chris@102: #   endif
Chris@102:       return unrolled_byte_loops<T, n_bytes>::load_little
Chris@102:         (static_cast<const unsigned char*>(bytes));
Chris@102:     }
Chris@102: 
Chris@102:     template <typename T, std::size_t n_bytes>
Chris@102:     inline
Chris@102:     void store_big_endian(void* bytes, T value) BOOST_NOEXCEPT
Chris@102:     {
Chris@102:       unrolled_byte_loops<T, n_bytes>::store_big
Chris@102:         (static_cast<char*>(bytes) + n_bytes, value);
Chris@102:     }
Chris@102: 
Chris@102:     template <typename T, std::size_t n_bytes>
Chris@102:     inline
Chris@102:     void store_little_endian(void* bytes, T value) BOOST_NOEXCEPT
Chris@102:     {
Chris@102: #     if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86)
Chris@102:       // On x86 (which is little endian), unaligned stores are permitted
Chris@102:       if (sizeof(T) == n_bytes)  // GCC 4.9, VC++ 14.0, and probably others, elide this
Chris@102:                                  // test and generate code only for the applicable return
Chris@102:                                  // case since sizeof(T) and n_bytes are known at compile
Chris@102:                                  // time.
Chris@102:       {
Chris@102:         *reinterpret_cast<T *>(bytes) = value;
Chris@102:         return;
Chris@102:       }
Chris@102: #     endif
Chris@102:       unrolled_byte_loops<T, n_bytes>::store_little
Chris@102:         (static_cast<char*>(bytes), value);
Chris@102:     }
Chris@102: 
Chris@102:   } // namespace detail
Chris@102: 
Chris@102: # ifdef BOOST_ENDIAN_LOG
Chris@102:     bool endian_log(true);
Chris@102: # endif
Chris@102: 
Chris@102: //  endian_buffer class template specializations  --------------------------------------//
Chris@102: 
Chris@102:     //  Specializations that represent unaligned bytes.
Chris@102:     //  Taking an integer type as a parameter provides a nice way to pass both
Chris@102:     //  the size and signedness of the desired integer and get the appropriate
Chris@102:     //  corresponding integer type for the interface.
Chris@102: 
Chris@102:     // Q: Should endian_buffer supply "value_type operator value_type() const noexcept"?
Chris@102:     // A: No. The rationale for endian_buffers is to prevent high-cost hidden
Chris@102:     //    conversions. If an implicit conversion operator is supplied, hidden conversions
Chris@102:     //    can occur.
Chris@102: 
Chris@102:     //  unaligned big endian_buffer specialization
Chris@102:     template <typename T, std::size_t n_bits>
Chris@102:     class endian_buffer< order::big, T, n_bits, align::no >
Chris@102:     {
Chris@102:         BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
Chris@102:       public:
Chris@102:         typedef T value_type;
Chris@102: #     ifndef BOOST_ENDIAN_NO_CTORS
Chris@102:         endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
Chris@102:         explicit endian_buffer(T val) BOOST_NOEXCEPT
Chris@102:         { 
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if ( endian_log )
Chris@102:             std::cout << "big, unaligned, "
Chris@102:               << n_bits << "-bits, construct(" << val << ")\n";
Chris@102: #       endif
Chris@102:           detail::store_big_endian<T, n_bits/8>(m_value, val);
Chris@102:         }
Chris@102: #     endif
Chris@102:         endian_buffer & operator=(T val) BOOST_NOEXCEPT
Chris@102:         {
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if (endian_log)
Chris@102:             std::cout << "big, unaligned, " << n_bits << "-bits, assign(" << val << ")\n";
Chris@102: #       endif
Chris@102:           detail::store_big_endian<T, n_bits/8>(m_value, val);
Chris@102:           return *this;
Chris@102:         }
Chris@102:         value_type value() const BOOST_NOEXCEPT
Chris@102:         { 
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if ( endian_log )
Chris@102:             std::cout << "big, unaligned, " << n_bits << "-bits, convert("
Chris@102:               << detail::load_big_endian<T, n_bits/8>(m_value) << ")\n";
Chris@102: #       endif
Chris@102:           return detail::load_big_endian<T, n_bits/8>(m_value);
Chris@102:         }
Chris@102:         const char* data() const BOOST_NOEXCEPT  { return m_value; }
Chris@102:       protected:
Chris@102:         char m_value[n_bits/8];
Chris@102:     };
Chris@102: 
Chris@102:     //  unaligned little endian_buffer specialization
Chris@102:     template <typename T, std::size_t n_bits>
Chris@102:     class endian_buffer< order::little, T, n_bits, align::no >
Chris@102:     {
Chris@102:         BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
Chris@102:       public:
Chris@102:         typedef T value_type;
Chris@102: #     ifndef BOOST_ENDIAN_NO_CTORS
Chris@102:         endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
Chris@102:         explicit endian_buffer(T val) BOOST_NOEXCEPT
Chris@102:         { 
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if ( endian_log )
Chris@102:             std::cout << "little, unaligned, " << n_bits << "-bits, construct("
Chris@102:               << val << ")\n";
Chris@102: #       endif
Chris@102:           detail::store_little_endian<T, n_bits/8>(m_value, val);
Chris@102:         }
Chris@102: #     endif
Chris@102:         endian_buffer & operator=(T val) BOOST_NOEXCEPT
Chris@102:           { detail::store_little_endian<T, n_bits/8>(m_value, val); return *this; }
Chris@102:         value_type value() const BOOST_NOEXCEPT
Chris@102:         { 
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if ( endian_log )
Chris@102:             std::cout << "little, unaligned, " << n_bits << "-bits, convert("
Chris@102:               << detail::load_little_endian<T, n_bits/8>(m_value) << ")\n";
Chris@102: #       endif
Chris@102:           return detail::load_little_endian<T, n_bits/8>(m_value);
Chris@102:         }
Chris@102:         const char* data() const BOOST_NOEXCEPT  { return m_value; }
Chris@102:       protected:
Chris@102:         char m_value[n_bits/8];
Chris@102:     };
Chris@102: 
Chris@102:   //  align::yes specializations; only n_bits == 16/32/64 supported
Chris@102: 
Chris@102:     //  aligned big endian_buffer specialization
Chris@102:     template <typename T, std::size_t n_bits>
Chris@102:     class endian_buffer<order::big, T, n_bits, align::yes>
Chris@102:     {
Chris@102:         BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
Chris@102:         BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
Chris@102:       public:
Chris@102:         typedef T value_type;
Chris@102: #     ifndef BOOST_ENDIAN_NO_CTORS
Chris@102:         endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
Chris@102:         explicit endian_buffer(T val) BOOST_NOEXCEPT
Chris@102:         {
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if ( endian_log )
Chris@102:             std::cout << "big, aligned, " << n_bits
Chris@102:               << "-bits, construct(" << val << ")\n";
Chris@102: #       endif
Chris@102:           m_value = ::boost::endian::native_to_big(val);
Chris@102:         }
Chris@102: 
Chris@102: #     endif  
Chris@102:         endian_buffer& operator=(T val) BOOST_NOEXCEPT
Chris@102:         {
Chris@102:           m_value = ::boost::endian::native_to_big(val);
Chris@102:           return *this;
Chris@102:         }
Chris@102:         //operator value_type() const BOOST_NOEXCEPT
Chris@102:         //{                                                                       
Chris@102:         //  return ::boost::endian::big_to_native(m_value);
Chris@102:         //}
Chris@102:         value_type value() const BOOST_NOEXCEPT
Chris@102:         {
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if ( endian_log )
Chris@102:             std::cout << "big, aligned, " << n_bits << "-bits, convert("
Chris@102:               << ::boost::endian::big_to_native(m_value) << ")\n";
Chris@102: #       endif
Chris@102:           return ::boost::endian::big_to_native(m_value);
Chris@102:         }
Chris@102:         const char* data() const BOOST_NOEXCEPT
Chris@102:           {return reinterpret_cast<const char*>(&m_value);}
Chris@102:       protected:
Chris@102:         T m_value;
Chris@102:     };
Chris@102: 
Chris@102:     //  aligned little endian_buffer specialization
Chris@102:     template <typename T, std::size_t n_bits>
Chris@102:     class endian_buffer<order::little, T, n_bits, align::yes>
Chris@102:     {
Chris@102:         BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits );
Chris@102:         BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 );
Chris@102:       public:
Chris@102:         typedef T value_type;
Chris@102: #     ifndef BOOST_ENDIAN_NO_CTORS
Chris@102:         endian_buffer() BOOST_ENDIAN_DEFAULT_CONSTRUCT
Chris@102:         explicit endian_buffer(T val) BOOST_NOEXCEPT
Chris@102:         {
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if ( endian_log )
Chris@102:             std::cout << "little, aligned, " << n_bits
Chris@102:               << "-bits, construct(" << val << ")\n";
Chris@102: #       endif
Chris@102:           m_value = ::boost::endian::native_to_little(val);
Chris@102:         }
Chris@102: 
Chris@102: #     endif  
Chris@102:         endian_buffer& operator=(T val) BOOST_NOEXCEPT
Chris@102:         {
Chris@102:           m_value = ::boost::endian::native_to_little(val);
Chris@102:           return *this;
Chris@102:         }
Chris@102:         value_type value() const BOOST_NOEXCEPT
Chris@102:         {
Chris@102: #       ifdef BOOST_ENDIAN_LOG
Chris@102:           if ( endian_log )
Chris@102:             std::cout << "little, aligned, " << n_bits << "-bits, convert("
Chris@102:               << ::boost::endian::little_to_native(m_value) << ")\n";
Chris@102: #       endif
Chris@102:           return ::boost::endian::little_to_native(m_value);
Chris@102:         }
Chris@102:         const char* data() const BOOST_NOEXCEPT
Chris@102:           {return reinterpret_cast<const char*>(&m_value);}
Chris@102:       protected:
Chris@102:         T m_value;
Chris@102:     };
Chris@102: 
Chris@102: } // namespace endian
Chris@102: } // namespace boost
Chris@102: 
Chris@102: #if defined(__BORLANDC__) || defined( __CODEGEARC__)
Chris@102: # pragma pack(pop)
Chris@102: #endif
Chris@102: 
Chris@102: #if defined(_MSC_VER)  
Chris@102: # pragma warning(pop)  
Chris@102: #endif 
Chris@102: 
Chris@102: #endif // BOOST_ENDIAN_BUFFERS_HPP