diff options
Diffstat (limited to 'boost/endian/arithmetic.hpp')
| -rw-r--r-- | boost/endian/arithmetic.hpp | 413 |
1 files changed, 413 insertions, 0 deletions
diff --git a/boost/endian/arithmetic.hpp b/boost/endian/arithmetic.hpp new file mode 100644 index 0000000000..d8bcbe62b4 --- /dev/null +++ b/boost/endian/arithmetic.hpp @@ -0,0 +1,413 @@ +// boost/endian/arithmetic.hpp -------------------------------------------------------// + +// (C) Copyright Darin Adler 2000 +// (C) Copyright Beman Dawes 2006, 2009, 2014 + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// See library home page at http://www.boost.org/libs/endian + +//--------------------------------------------------------------------------------------// + +// Original design developed by Darin Adler based on classes developed by Mark +// Borgerding. Four original class templates were combined into a single endian +// class template by Beman Dawes, who also added the unrolled_byte_loops sign +// partial specialization to correctly extend the sign when cover integer size +// differs from endian representation size. + +// TODO: When a compiler supporting constexpr becomes available, try possible uses. + +#ifndef BOOST_ENDIAN_ARITHMETIC_HPP +#define BOOST_ENDIAN_ARITHMETIC_HPP + +#if defined(_MSC_VER) +# pragma warning(push) +# pragma warning(disable:4365) // conversion ... signed/unsigned mismatch +#endif + +#ifdef BOOST_ENDIAN_LOG +# include <iostream> +#endif + +#if defined(__BORLANDC__) || defined( __CODEGEARC__) +# pragma pack(push, 1) +#endif + +#include <boost/config.hpp> +#include <boost/predef/detail/endian_compat.h> +#include <boost/endian/conversion.hpp> +#include <boost/endian/buffers.hpp> +#define BOOST_ENDIAN_MINIMAL_COVER_OPERATORS +#include <boost/endian/detail/cover_operators.hpp> +#undef BOOST_ENDIAN_MINIMAL_COVER_OPERATORS +#include <boost/type_traits/is_signed.hpp> +#include <boost/cstdint.hpp> +#include <boost/static_assert.hpp> +#include <boost/core/scoped_enum.hpp> +#include <iosfwd> +#include <climits> + +# if CHAR_BIT != 8 +# error Platforms with CHAR_BIT != 8 are not supported +# endif + +# ifdef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS +# define BOOST_ENDIAN_DEFAULT_CONSTRUCT {} // C++03 +# else +# define BOOST_ENDIAN_DEFAULT_CONSTRUCT = default; // C++0x +# endif + +# if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && defined(BOOST_ENDIAN_FORCE_PODNESS) +# define BOOST_ENDIAN_NO_CTORS +# endif + +# ifndef BOOST_ENDIAN_EXPLICIT_CTORS +# define BOOST_ENDIAN_EXPLICIT_OPT +# else +# define BOOST_ENDIAN_EXPLICIT_OPT explicit +# endif + +//---------------------------------- synopsis ----------------------------------------// + +namespace boost +{ +namespace endian +{ + + template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits, + BOOST_SCOPED_ENUM(align) A = align::no> + class endian_arithmetic; + + // big endian signed integer aligned types + typedef endian_arithmetic<order::big, int8_t, 8, align::yes> big_int8_at; + typedef endian_arithmetic<order::big, int16_t, 16, align::yes> big_int16_at; + typedef endian_arithmetic<order::big, int32_t, 32, align::yes> big_int32_at; + typedef endian_arithmetic<order::big, int64_t, 64, align::yes> big_int64_at; + + // big endian unsigned integer aligned types + typedef endian_arithmetic<order::big, uint8_t, 8, align::yes> big_uint8_at; + typedef endian_arithmetic<order::big, uint16_t, 16, align::yes> big_uint16_at; + typedef endian_arithmetic<order::big, uint32_t, 32, align::yes> big_uint32_at; + typedef endian_arithmetic<order::big, uint64_t, 64, align::yes> big_uint64_at; + + // little endian signed integer aligned types + typedef endian_arithmetic<order::little, int8_t, 8, align::yes> little_int8_at; + typedef endian_arithmetic<order::little, int16_t, 16, align::yes> little_int16_at; + typedef endian_arithmetic<order::little, int32_t, 32, align::yes> little_int32_at; + typedef endian_arithmetic<order::little, int64_t, 64, align::yes> little_int64_at; + + // little endian unsigned integer aligned types + typedef endian_arithmetic<order::little, uint8_t, 8, align::yes> little_uint8_at; + typedef endian_arithmetic<order::little, uint16_t, 16, align::yes> little_uint16_at; + typedef endian_arithmetic<order::little, uint32_t, 32, align::yes> little_uint32_at; + typedef endian_arithmetic<order::little, uint64_t, 64, align::yes> little_uint64_at; + + // aligned native endian typedefs are not provided because + // <cstdint> types are superior for this use case + + // big endian signed integer unaligned types + typedef endian_arithmetic<order::big, int_least8_t, 8> big_int8_t; + typedef endian_arithmetic<order::big, int_least16_t, 16> big_int16_t; + typedef endian_arithmetic<order::big, int_least32_t, 24> big_int24_t; + typedef endian_arithmetic<order::big, int_least32_t, 32> big_int32_t; + typedef endian_arithmetic<order::big, int_least64_t, 40> big_int40_t; + typedef endian_arithmetic<order::big, int_least64_t, 48> big_int48_t; + typedef endian_arithmetic<order::big, int_least64_t, 56> big_int56_t; + typedef endian_arithmetic<order::big, int_least64_t, 64> big_int64_t; + + // big endian unsigned integer unaligned types + typedef endian_arithmetic<order::big, uint_least8_t, 8> big_uint8_t; + typedef endian_arithmetic<order::big, uint_least16_t, 16> big_uint16_t; + typedef endian_arithmetic<order::big, uint_least32_t, 24> big_uint24_t; + typedef endian_arithmetic<order::big, uint_least32_t, 32> big_uint32_t; + typedef endian_arithmetic<order::big, uint_least64_t, 40> big_uint40_t; + typedef endian_arithmetic<order::big, uint_least64_t, 48> big_uint48_t; + typedef endian_arithmetic<order::big, uint_least64_t, 56> big_uint56_t; + typedef endian_arithmetic<order::big, uint_least64_t, 64> big_uint64_t; + + // little endian signed integer unaligned types + typedef endian_arithmetic<order::little, int_least8_t, 8> little_int8_t; + typedef endian_arithmetic<order::little, int_least16_t, 16> little_int16_t; + typedef endian_arithmetic<order::little, int_least32_t, 24> little_int24_t; + typedef endian_arithmetic<order::little, int_least32_t, 32> little_int32_t; + typedef endian_arithmetic<order::little, int_least64_t, 40> little_int40_t; + typedef endian_arithmetic<order::little, int_least64_t, 48> little_int48_t; + typedef endian_arithmetic<order::little, int_least64_t, 56> little_int56_t; + typedef endian_arithmetic<order::little, int_least64_t, 64> little_int64_t; + + // little endian unsigned integer unaligned types + typedef endian_arithmetic<order::little, uint_least8_t, 8> little_uint8_t; + typedef endian_arithmetic<order::little, uint_least16_t, 16> little_uint16_t; + typedef endian_arithmetic<order::little, uint_least32_t, 24> little_uint24_t; + typedef endian_arithmetic<order::little, uint_least32_t, 32> little_uint32_t; + typedef endian_arithmetic<order::little, uint_least64_t, 40> little_uint40_t; + typedef endian_arithmetic<order::little, uint_least64_t, 48> little_uint48_t; + typedef endian_arithmetic<order::little, uint_least64_t, 56> little_uint56_t; + typedef endian_arithmetic<order::little, uint_least64_t, 64> little_uint64_t; + +# ifdef BOOST_BIG_ENDIAN + // native endian signed integer unaligned types + typedef big_int8_t native_int8_t; + typedef big_int16_t native_int16_t; + typedef big_int24_t native_int24_t; + typedef big_int32_t native_int32_t; + typedef big_int40_t native_int40_t; + typedef big_int48_t native_int48_t; + typedef big_int56_t native_int56_t; + typedef big_int64_t native_int64_t; + + // native endian unsigned integer unaligned types + typedef big_uint8_t native_uint8_t; + typedef big_uint16_t native_uint16_t; + typedef big_uint24_t native_uint24_t; + typedef big_uint32_t native_uint32_t; + typedef big_uint40_t native_uint40_t; + typedef big_uint48_t native_uint48_t; + typedef big_uint56_t native_uint56_t; + typedef big_uint64_t native_uint64_t; +# else + // native endian signed integer unaligned types + typedef little_int8_t native_int8_t; + typedef little_int16_t native_int16_t; + typedef little_int24_t native_int24_t; + typedef little_int32_t native_int32_t; + typedef little_int40_t native_int40_t; + typedef little_int48_t native_int48_t; + typedef little_int56_t native_int56_t; + typedef little_int64_t native_int64_t; + + // native endian unsigned integer unaligned types + typedef little_uint8_t native_uint8_t; + typedef little_uint16_t native_uint16_t; + typedef little_uint24_t native_uint24_t; + typedef little_uint32_t native_uint32_t; + typedef little_uint40_t native_uint40_t; + typedef little_uint48_t native_uint48_t; + typedef little_uint56_t native_uint56_t; + typedef little_uint64_t native_uint64_t; +# endif + +# ifdef BOOST_ENDIAN_DEPRECATED_NAMES + + typedef order endianness; + typedef align alignment; + +# ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES + template <BOOST_SCOPED_ENUM(order) Order, class T, std::size_t n_bits, + BOOST_SCOPED_ENUM(align) Align = align::no> + using endian = endian_arithmetic<Order, T, n_bits, Align>; +# endif + + // unaligned big endian signed integer types + typedef endian_arithmetic< order::big, int_least8_t, 8 > big8_t; + typedef endian_arithmetic< order::big, int_least16_t, 16 > big16_t; + typedef endian_arithmetic< order::big, int_least32_t, 24 > big24_t; + typedef endian_arithmetic< order::big, int_least32_t, 32 > big32_t; + typedef endian_arithmetic< order::big, int_least64_t, 40 > big40_t; + typedef endian_arithmetic< order::big, int_least64_t, 48 > big48_t; + typedef endian_arithmetic< order::big, int_least64_t, 56 > big56_t; + typedef endian_arithmetic< order::big, int_least64_t, 64 > big64_t; + + // unaligned big endian_arithmetic unsigned integer types + typedef endian_arithmetic< order::big, uint_least8_t, 8 > ubig8_t; + typedef endian_arithmetic< order::big, uint_least16_t, 16 > ubig16_t; + typedef endian_arithmetic< order::big, uint_least32_t, 24 > ubig24_t; + typedef endian_arithmetic< order::big, uint_least32_t, 32 > ubig32_t; + typedef endian_arithmetic< order::big, uint_least64_t, 40 > ubig40_t; + typedef endian_arithmetic< order::big, uint_least64_t, 48 > ubig48_t; + typedef endian_arithmetic< order::big, uint_least64_t, 56 > ubig56_t; + typedef endian_arithmetic< order::big, uint_least64_t, 64 > ubig64_t; + + // unaligned little endian_arithmetic signed integer types + typedef endian_arithmetic< order::little, int_least8_t, 8 > little8_t; + typedef endian_arithmetic< order::little, int_least16_t, 16 > little16_t; + typedef endian_arithmetic< order::little, int_least32_t, 24 > little24_t; + typedef endian_arithmetic< order::little, int_least32_t, 32 > little32_t; + typedef endian_arithmetic< order::little, int_least64_t, 40 > little40_t; + typedef endian_arithmetic< order::little, int_least64_t, 48 > little48_t; + typedef endian_arithmetic< order::little, int_least64_t, 56 > little56_t; + typedef endian_arithmetic< order::little, int_least64_t, 64 > little64_t; + + // unaligned little endian_arithmetic unsigned integer types + typedef endian_arithmetic< order::little, uint_least8_t, 8 > ulittle8_t; + typedef endian_arithmetic< order::little, uint_least16_t, 16 > ulittle16_t; + typedef endian_arithmetic< order::little, uint_least32_t, 24 > ulittle24_t; + typedef endian_arithmetic< order::little, uint_least32_t, 32 > ulittle32_t; + typedef endian_arithmetic< order::little, uint_least64_t, 40 > ulittle40_t; + typedef endian_arithmetic< order::little, uint_least64_t, 48 > ulittle48_t; + typedef endian_arithmetic< order::little, uint_least64_t, 56 > ulittle56_t; + typedef endian_arithmetic< order::little, uint_least64_t, 64 > ulittle64_t; + + // unaligned native endian_arithmetic signed integer types + typedef endian_arithmetic< order::native, int_least8_t, 8 > native8_t; + typedef endian_arithmetic< order::native, int_least16_t, 16 > native16_t; + typedef endian_arithmetic< order::native, int_least32_t, 24 > native24_t; + typedef endian_arithmetic< order::native, int_least32_t, 32 > native32_t; + typedef endian_arithmetic< order::native, int_least64_t, 40 > native40_t; + typedef endian_arithmetic< order::native, int_least64_t, 48 > native48_t; + typedef endian_arithmetic< order::native, int_least64_t, 56 > native56_t; + typedef endian_arithmetic< order::native, int_least64_t, 64 > native64_t; + + // unaligned native endian_arithmetic unsigned integer types + typedef endian_arithmetic< order::native, uint_least8_t, 8 > unative8_t; + typedef endian_arithmetic< order::native, uint_least16_t, 16 > unative16_t; + typedef endian_arithmetic< order::native, uint_least32_t, 24 > unative24_t; + typedef endian_arithmetic< order::native, uint_least32_t, 32 > unative32_t; + typedef endian_arithmetic< order::native, uint_least64_t, 40 > unative40_t; + typedef endian_arithmetic< order::native, uint_least64_t, 48 > unative48_t; + typedef endian_arithmetic< order::native, uint_least64_t, 56 > unative56_t; + typedef endian_arithmetic< order::native, uint_least64_t, 64 > unative64_t; + + // aligned native endian_arithmetic typedefs are not provided because + // <cstdint> types are superior for this use case + + typedef endian_arithmetic< order::big, int16_t, 16, align::yes > aligned_big16_t; + typedef endian_arithmetic< order::big, uint16_t, 16, align::yes > aligned_ubig16_t; + typedef endian_arithmetic< order::little, int16_t, 16, align::yes > aligned_little16_t; + typedef endian_arithmetic< order::little, uint16_t, 16, align::yes > aligned_ulittle16_t; + + typedef endian_arithmetic< order::big, int32_t, 32, align::yes > aligned_big32_t; + typedef endian_arithmetic< order::big, uint32_t, 32, align::yes > aligned_ubig32_t; + typedef endian_arithmetic< order::little, int32_t, 32, align::yes > aligned_little32_t; + typedef endian_arithmetic< order::little, uint32_t, 32, align::yes > aligned_ulittle32_t; + + typedef endian_arithmetic< order::big, int64_t, 64, align::yes > aligned_big64_t; + typedef endian_arithmetic< order::big, uint64_t, 64, align::yes > aligned_ubig64_t; + typedef endian_arithmetic< order::little, int64_t, 64, align::yes > aligned_little64_t; + typedef endian_arithmetic< order::little, uint64_t, 64, align::yes > aligned_ulittle64_t; + +# endif + +//---------------------------------- end synopsis ------------------------------------// + +// endian class template specializations ---------------------------------------------// + + // Specializations that represent unaligned bytes. + // Taking an integer type as a parameter provides a nice way to pass both + // the size and signness of the desired integer and get the appropriate + // corresponding integer type for the interface. + + // unaligned integer big endian specialization + template <typename T, std::size_t n_bits> + class endian_arithmetic< order::big, T, n_bits, align::no > + : public endian_buffer< order::big, T, n_bits, align::no >, + cover_operators<endian_arithmetic<order::big, T, n_bits>, T> + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "big, unaligned, " << n_bits << "-bits, construct(" << val << ")\n"; +# endif + detail::store_big_endian<T, n_bits/8>(this->m_value, val); + } +# endif + endian_arithmetic& operator=(T val) BOOST_NOEXCEPT + { detail::store_big_endian<T, n_bits/8>(this->m_value, val); return *this; } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // unaligned little endian specialization + template <typename T, std::size_t n_bits> + class endian_arithmetic< order::little, T, n_bits, align::no > + : public endian_buffer< order::little, T, n_bits, align::no >, + cover_operators< endian_arithmetic< order::little, T, n_bits >, T > + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "little, unaligned, " << n_bits << "-bits, construct(" << val << ")\n"; +# endif + detail::store_little_endian<T, n_bits/8>(this->m_value, val); + } +# endif + endian_arithmetic& operator=(T val) BOOST_NOEXCEPT + { detail::store_little_endian<T, n_bits/8>(this->m_value, val); return *this; } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // align::yes specializations; only n_bits == 16/32/64 supported + + // aligned big endian specialization + template <typename T, std::size_t n_bits> + class endian_arithmetic<order::big, T, n_bits, align::yes> + : public endian_buffer< order::big, T, n_bits, align::yes >, + cover_operators<endian_arithmetic<order::big, T, n_bits, align::yes>, T> + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "big, aligned, " << n_bits << "-bits, construct(" << val << ")\n"; +# endif + this->m_value = ::boost::endian::native_to_big(val); + } + +# endif + endian_arithmetic& operator=(T val) BOOST_NOEXCEPT + { + this->m_value = ::boost::endian::native_to_big(val); + return *this; + } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + + // aligned little endian specialization + template <typename T, std::size_t n_bits> + class endian_arithmetic<order::little, T, n_bits, align::yes> + : public endian_buffer< order::little, T, n_bits, align::yes >, + cover_operators<endian_arithmetic<order::little, T, n_bits, align::yes>, T> + { + BOOST_STATIC_ASSERT( (n_bits/8)*8 == n_bits ); + BOOST_STATIC_ASSERT( sizeof(T) == n_bits/8 ); + public: + typedef T value_type; +# ifndef BOOST_ENDIAN_NO_CTORS + endian_arithmetic() BOOST_ENDIAN_DEFAULT_CONSTRUCT + BOOST_ENDIAN_EXPLICIT_OPT endian_arithmetic(T val) BOOST_NOEXCEPT + { +# ifdef BOOST_ENDIAN_LOG + if ( endian_log ) + std::cout << "little, aligned, " << n_bits << "-bits, construct(" << val << ")\n"; +# endif + this->m_value = ::boost::endian::native_to_little(val); + } +# endif + endian_arithmetic& operator=(T val) BOOST_NOEXCEPT + { + this->m_value = ::boost::endian::native_to_little(val); + return *this; + } + operator value_type() const BOOST_NOEXCEPT { return this->value(); } + }; + +} // namespace endian +} // namespace boost + +#if defined(__BORLANDC__) || defined( __CODEGEARC__) +# pragma pack(pop) +#endif + +#if defined(_MSC_VER) +# pragma warning(pop) +#endif + +#endif // BOOST_ENDIAN_ARITHMETIC_HPP |