From 0fef88ab3f1b7c76f170254cab362abec9fd494f Mon Sep 17 00:00:00 2001 From: Beman Date: Sun, 12 May 2013 08:58:44 -0400 Subject: [PATCH] Change names to make room for modify-in-place names. --- include/boost/endian/converters.hpp | 274 +++++++++++++++------------- test/converter_test.cpp | 92 +++++----- 2 files changed, 194 insertions(+), 172 deletions(-) diff --git a/include/boost/endian/converters.hpp b/include/boost/endian/converters.hpp index 72cb7b4..ee3ed95 100644 --- a/include/boost/endian/converters.hpp +++ b/include/boost/endian/converters.hpp @@ -26,42 +26,53 @@ namespace endian BOOST_SCOPED_ENUM_START(order) { big, little, native }; BOOST_SCOPED_ENUM_END # define BOOST_ENDIAN_ORDER_ENUM_DEFINED #endif + +//--------------------------------------------------------------------------------------// +// value returning interface // +// suggested by Phil Endecott // +//--------------------------------------------------------------------------------------// // reverse byte order (i.e. endianness) - // value returning interface approach suggested by Phil Endecott. - inline int16_t reverse_bytes(int16_t x) BOOST_NOEXCEPT; - inline int32_t reverse_bytes(int32_t x) BOOST_NOEXCEPT; - inline int64_t reverse_bytes(int64_t x) BOOST_NOEXCEPT; - inline uint16_t reverse_bytes(uint16_t x) BOOST_NOEXCEPT; - inline uint32_t reverse_bytes(uint32_t x) BOOST_NOEXCEPT; - inline uint64_t reverse_bytes(uint64_t x) BOOST_NOEXCEPT; + // + inline int16_t reverse_value(int16_t x) BOOST_NOEXCEPT; + inline int32_t reverse_value(int32_t x) BOOST_NOEXCEPT; + inline int64_t reverse_value(int64_t x) BOOST_NOEXCEPT; + inline uint16_t reverse_value(uint16_t x) BOOST_NOEXCEPT; + inline uint32_t reverse_value(uint32_t x) BOOST_NOEXCEPT; + inline uint64_t reverse_value(uint64_t x) BOOST_NOEXCEPT; - // reverse_bytes overloads for floating point types as requested by Vicente + // reverse_value overloads for floating point types as requested by Vicente // Botet and others. // TODO: Track progress of Floating-Point Typedefs Having Specified Widths proposal (N3626) - inline float reverse_bytes(float x) BOOST_NOEXCEPT; - inline double reverse_bytes(double x) BOOST_NOEXCEPT; + inline float reverse_value(float x) BOOST_NOEXCEPT; + inline double reverse_value(double x) BOOST_NOEXCEPT; - // general reverse_bytes function template to meet requests for UDT support by Vicente - // Botet and others. - template - inline T reverse_bytes(T x) BOOST_NOEXCEPT; // convert little to big or visa versa + namespace detail + // This function is unsafe for general use, so is placed in namespace detail. + // Think of what happens if you reverse_value a std::pair; the bytes + // from first end up in second and the bytes from second end up in first. Not good! + { + // general reverse_value function template to meet requests for UDT support by Vicente + // Botet and others. + template + inline T reverse_value(T x) BOOST_NOEXCEPT; // convert little to big or visa versa + } // reverse bytes unless native endianness is big - // possible names: reverse_unless_native_big, reverse_bytes_unless_big, reverse_unless_big + // possible names: reverse_unless_native_big, reverse_value_unless_big, reverse_unless_big template - inline T big_endian(T x) BOOST_NOEXCEPT; - // Return: x if native endian order is big, otherwise reverse_bytes(x) + inline T big_endian_value(T x) BOOST_NOEXCEPT; + // Return: x if native endian order is big, otherwise reverse_value(x) // reverse bytes unless native endianness is little - // possible names: reverse_unless_native_little, reverse_bytes_unless_little, reverse_unless_little + // possible names: reverse_unless_native_little, reverse_value_unless_little, reverse_unless_little template - inline T little_endian(T x) BOOST_NOEXCEPT; - // Return: x if native endian order is little, otherwise reverse_bytes(x); + inline T little_endian_value(T x) BOOST_NOEXCEPT; + // Return: x if native endian order is little, otherwise reverse_value(x); // compile-time generic byte order conversion template - T convert(T from) BOOST_NOEXCEPT; + T convert_value(T from) BOOST_NOEXCEPT; // runtime actual byte-order determination inline BOOST_SCOPED_ENUM(order) actual_order(BOOST_SCOPED_ENUM(order) o) BOOST_NOEXCEPT; @@ -69,17 +80,25 @@ namespace endian // runtime byte-order conversion template - T convert(T from, BOOST_SCOPED_ENUM(order) from_order, + T convert_value(T from, BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order) BOOST_NOEXCEPT; -//----------------------------------- implementation -----------------------------------// -// -- reverse_bytes portable approach suggested by tymofey, with avoidance of -// undefined behavior as suggested by Giovanni Piero Deretta, and a further -// refinement suggested by Pyry Jahkola. -// -- reverse_bytes intrinsic approach suggested by David Stone, who privided his -// Boost licensed macro implementation. + +//----------------------------------- end synopsis -------------------------------------// + +//--------------------------------------------------------------------------------------// +// // +// implementation // +// // +// -- reverse_value portable approach suggested by tymofey, with avoidance of // +// undefined behavior as suggested by Giovanni Piero Deretta, and a further // +// refinement suggested by Pyry Jahkola. // +// -- reverse_value intrinsic approach suggested by reviewers, and by David Stone, // +// who provided his Boost licensed macro implementation (see detail/intrinsic.hpp // +// // +//--------------------------------------------------------------------------------------// - inline int16_t reverse_bytes(int16_t x) BOOST_NOEXCEPT + inline int16_t reverse_value(int16_t x) BOOST_NOEXCEPT { # ifdef BOOST_ENDIAN_NO_INTRINSICS return (static_cast(x) << 8) @@ -89,7 +108,7 @@ namespace endian # endif } - inline int32_t reverse_bytes(int32_t x) BOOST_NOEXCEPT + inline int32_t reverse_value(int32_t x) BOOST_NOEXCEPT { # ifdef BOOST_ENDIAN_NO_INTRINSICS uint32_t step16; @@ -102,7 +121,7 @@ namespace endian # endif } - inline int64_t reverse_bytes(int64_t x) BOOST_NOEXCEPT + inline int64_t reverse_value(int64_t x) BOOST_NOEXCEPT { # ifdef BOOST_ENDIAN_NO_INTRINSICS uint64_t step32, step16; @@ -116,7 +135,7 @@ namespace endian # endif } - inline uint16_t reverse_bytes(uint16_t x) BOOST_NOEXCEPT + inline uint16_t reverse_value(uint16_t x) BOOST_NOEXCEPT { # ifdef BOOST_ENDIAN_NO_INTRINSICS return (x << 8) @@ -126,7 +145,7 @@ namespace endian # endif } - inline uint32_t reverse_bytes(uint32_t x) BOOST_NOEXCEPT + inline uint32_t reverse_value(uint32_t x) BOOST_NOEXCEPT { # ifdef BOOST_ENDIAN_NO_INTRINSICS uint32_t step16; @@ -139,7 +158,7 @@ namespace endian # endif } - inline uint64_t reverse_bytes(uint64_t x) BOOST_NOEXCEPT + inline uint64_t reverse_value(uint64_t x) BOOST_NOEXCEPT { # ifdef BOOST_ENDIAN_NO_INTRINSICS uint64_t step32, step16; @@ -153,141 +172,144 @@ namespace endian # endif } - inline float reverse_bytes(float x) BOOST_NOEXCEPT + inline float reverse_value(float x) BOOST_NOEXCEPT { BOOST_STATIC_ASSERT_MSG(sizeof(float) == sizeof(uint32_t), "boost::endian only supprts sizeof(float) == 4; please report error to boost mailing list"); - uint32_t tmp = reverse_bytes(*(const uint32_t*)&x); + uint32_t tmp = reverse_value(*(const uint32_t*)&x); return *(const float*)&tmp; } - inline double reverse_bytes(double x) BOOST_NOEXCEPT + inline double reverse_value(double x) BOOST_NOEXCEPT { BOOST_STATIC_ASSERT_MSG(sizeof(double) == sizeof(uint64_t), "boost::endian only supprts sizeof(double) == 8; please report error to boost mailing list"); - uint64_t tmp = reverse_bytes(*(const uint64_t*)&x); + uint64_t tmp = reverse_value(*(const uint64_t*)&x); return *(const double*)&tmp; } -// general reverse_bytes function template implementation approach using std::reverse -// suggested by Mathias Gaunard - template - inline T reverse_bytes(T x) BOOST_NOEXCEPT + namespace detail // this function is unsafe for general use, so placed in namespace detail { - T tmp(x); - std::reverse( - reinterpret_cast(&tmp), - reinterpret_cast(&tmp) + sizeof(T)); - return tmp; + // general reverse_value function template implementation approach using std::reverse + // suggested by Mathias Gaunard + template + inline T reverse_value(T x) BOOST_NOEXCEPT + { + T tmp(x); + std::reverse( + reinterpret_cast(&tmp), + reinterpret_cast(&tmp) + sizeof(T)); + return tmp; + } } template - inline T big_endian(T x) BOOST_NOEXCEPT + inline T big_endian_value(T x) BOOST_NOEXCEPT { # ifdef BOOST_BIG_ENDIAN return x; # else - return reverse_bytes(x); + return reverse_value(x); # endif } template - inline T little_endian(T x) BOOST_NOEXCEPT + inline T little_endian_value(T x) BOOST_NOEXCEPT { # ifdef BOOST_LITTLE_ENDIAN return x; # else - return reverse_bytes(x); + return reverse_value(x); # endif } - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return x;} - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return x;} - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return x;} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return x;} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return x;} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return x;} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return x;} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return x;} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return x;} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return x;} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return x;} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return x;} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return x;} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return x;} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return x;} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return x;} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return x;} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return x;} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return x;} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return x;} - template<> inline float convert(float x) BOOST_NOEXCEPT {return x;} - template<> inline float convert(float x) BOOST_NOEXCEPT {return x;} - template<> inline float convert(float x) BOOST_NOEXCEPT {return x;} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return x;} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return x;} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return x;} - template<> inline double convert(double x) BOOST_NOEXCEPT {return x;} - template<> inline double convert(double x) BOOST_NOEXCEPT {return x;} - template<> inline double convert(double x) BOOST_NOEXCEPT {return x;} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return x;} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return x;} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return x;} - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return little_endian(x);} - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline int16_t convert(int16_t x) BOOST_NOEXCEPT {return little_endian(x);} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return little_endian_value(x);} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline int16_t convert_value(int16_t x) BOOST_NOEXCEPT {return little_endian_value(x);} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return little_endian(x);} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline uint16_t convert(uint16_t x) BOOST_NOEXCEPT {return little_endian(x);} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return little_endian_value(x);} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline uint16_t convert_value(uint16_t x) BOOST_NOEXCEPT {return little_endian_value(x);} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return little_endian(x);} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline int32_t convert(int32_t x) BOOST_NOEXCEPT {return little_endian(x);} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return little_endian_value(x);} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline int32_t convert_value(int32_t x) BOOST_NOEXCEPT {return little_endian_value(x);} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return little_endian(x);} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline uint32_t convert(uint32_t x) BOOST_NOEXCEPT {return little_endian(x);} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return little_endian_value(x);} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline uint32_t convert_value(uint32_t x) BOOST_NOEXCEPT {return little_endian_value(x);} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return little_endian(x);} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline int64_t convert(int64_t x) BOOST_NOEXCEPT {return little_endian(x);} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return little_endian_value(x);} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline int64_t convert_value(int64_t x) BOOST_NOEXCEPT {return little_endian_value(x);} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return little_endian(x);} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline uint64_t convert(uint64_t x) BOOST_NOEXCEPT {return little_endian(x);} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return little_endian_value(x);} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline uint64_t convert_value(uint64_t x) BOOST_NOEXCEPT {return little_endian_value(x);} - template<> inline float convert(float x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline float convert(float x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline float convert(float x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline float convert(float x) BOOST_NOEXCEPT {return little_endian(x);} - template<> inline float convert(float x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline float convert(float x) BOOST_NOEXCEPT {return little_endian(x);} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return little_endian_value(x);} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline float convert_value(float x) BOOST_NOEXCEPT {return little_endian_value(x);} - template<> inline double convert(double x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline double convert(double x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline double convert(double x) BOOST_NOEXCEPT {return reverse_bytes(x);} - template<> inline double convert(double x) BOOST_NOEXCEPT {return little_endian(x);} - template<> inline double convert(double x) BOOST_NOEXCEPT {return big_endian(x);} - template<> inline double convert(double x) BOOST_NOEXCEPT {return little_endian(x);} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return reverse_value(x);} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return little_endian_value(x);} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return big_endian_value(x);} + template<> inline double convert_value(double x) BOOST_NOEXCEPT {return little_endian_value(x);} inline BOOST_SCOPED_ENUM(order) actual_order(BOOST_SCOPED_ENUM(order) o) BOOST_NOEXCEPT { @@ -301,13 +323,13 @@ namespace endian } template - T convert(T from, BOOST_SCOPED_ENUM(order) from_order, + T convert_value(T from, BOOST_SCOPED_ENUM(order) from_order, BOOST_SCOPED_ENUM(order) to_order) BOOST_NOEXCEPT { if (actual_order(from_order) == order::big) - return actual_order(to_order) == order::big ? from : reverse_bytes(from); + return actual_order(to_order) == order::big ? from : reverse_value(from); // actual from_order is little - return actual_order(to_order) == order::little ? from : reverse_bytes(from); + return actual_order(to_order) == order::little ? from : reverse_value(from); } } // namespace endian diff --git a/test/converter_test.cpp b/test/converter_test.cpp index 408a90b..c98bdec 100644 --- a/test/converter_test.cpp +++ b/test/converter_test.cpp @@ -175,65 +175,65 @@ namespace big_value(big); little_value(little); - BOOST_TEST_EQ(be::reverse_bytes(big), little); - BOOST_TEST_EQ(be::reverse_bytes(little), big); - BOOST_TEST_EQ(be::reverse_bytes(big), little); - BOOST_TEST_EQ(be::reverse_bytes(little), big); + BOOST_TEST_EQ(be::reverse_value(big), little); + BOOST_TEST_EQ(be::reverse_value(little), big); + BOOST_TEST_EQ(be::detail::reverse_value(big), little); + BOOST_TEST_EQ(be::detail::reverse_value(little), big); - BOOST_TEST_EQ(be::big_endian(native), big); - BOOST_TEST_EQ(be::little_endian(native), little); - BOOST_TEST_EQ(be::big_endian(be::big_endian(native)), native); - BOOST_TEST_EQ(be::big_endian(be::big_endian(big)), big); - BOOST_TEST_EQ(be::big_endian(be::big_endian(little)), little); - BOOST_TEST_EQ(be::little_endian(be::little_endian(native)), native); - BOOST_TEST_EQ(be::little_endian(be::little_endian(big)), big); - BOOST_TEST_EQ(be::little_endian(be::little_endian(little)), little); + BOOST_TEST_EQ(be::big_endian_value(native), big); + BOOST_TEST_EQ(be::little_endian_value(native), little); + BOOST_TEST_EQ(be::big_endian_value(be::big_endian_value(native)), native); + BOOST_TEST_EQ(be::big_endian_value(be::big_endian_value(big)), big); + BOOST_TEST_EQ(be::big_endian_value(be::big_endian_value(little)), little); + BOOST_TEST_EQ(be::little_endian_value(be::little_endian_value(native)), native); + BOOST_TEST_EQ(be::little_endian_value(be::little_endian_value(big)), big); + BOOST_TEST_EQ(be::little_endian_value(be::little_endian_value(little)), little); # ifdef BOOST_BIG_ENDIAN - BOOST_TEST_EQ(be::reverse_bytes(native), little); - BOOST_TEST_EQ(be::reverse_bytes(native), little); - BOOST_TEST_EQ(be::big_endian(big), big); - BOOST_TEST_EQ(be::big_endian(big), big); - BOOST_TEST_EQ(be::big_endian(little), little); - BOOST_TEST_EQ(be::big_endian(little), little); - BOOST_TEST_EQ(be::big_endian(native), little); - BOOST_TEST_EQ(be::big_endian(native), little); + BOOST_TEST_EQ(be::reverse_value(native), little); + BOOST_TEST_EQ(be::detail::reverse_value(native), little); + BOOST_TEST_EQ(be::big_endian_value(big), big); + BOOST_TEST_EQ(be::big_endian_value(big), big); + BOOST_TEST_EQ(be::big_endian_value(little), little); + BOOST_TEST_EQ(be::big_endian_value(little), little); + BOOST_TEST_EQ(be::big_endian_value(native), little); + BOOST_TEST_EQ(be::big_endian_value(native), little); # else - BOOST_TEST_EQ(be::reverse_bytes(native), big); - BOOST_TEST_EQ(be::reverse_bytes(native), big); - BOOST_TEST_EQ(be::big_endian(big), little); - BOOST_TEST_EQ(be::big_endian(big), little); - BOOST_TEST_EQ(be::big_endian(little), big); - BOOST_TEST_EQ(be::big_endian(little), big); - BOOST_TEST_EQ(be::big_endian(native), big); - BOOST_TEST_EQ(be::big_endian(native), big); + BOOST_TEST_EQ(be::reverse_value(native), big); + BOOST_TEST_EQ(be::detail::reverse_value(native), big); + BOOST_TEST_EQ(be::big_endian_value(big), little); + BOOST_TEST_EQ(be::big_endian_value(big), little); + BOOST_TEST_EQ(be::big_endian_value(little), big); + BOOST_TEST_EQ(be::big_endian_value(little), big); + BOOST_TEST_EQ(be::big_endian_value(native), big); + BOOST_TEST_EQ(be::big_endian_value(native), big); # endif // compile time order determination - BOOST_TEST_EQ((be::convert(big)), big); - BOOST_TEST_EQ((be::convert(little)), little); - BOOST_TEST_EQ((be::convert(native)), native); + BOOST_TEST_EQ((be::convert_value(big)), big); + BOOST_TEST_EQ((be::convert_value(little)), little); + BOOST_TEST_EQ((be::convert_value(native)), native); - BOOST_TEST_EQ((be::convert(big)), little); - BOOST_TEST_EQ((be::convert(big)), native); - BOOST_TEST_EQ((be::convert(little)), big); - BOOST_TEST_EQ((be::convert(little)), native); - BOOST_TEST_EQ((be::convert(native)), big); - BOOST_TEST_EQ((be::convert(native)), native); + BOOST_TEST_EQ((be::convert_value(big)), little); + BOOST_TEST_EQ((be::convert_value(big)), native); + BOOST_TEST_EQ((be::convert_value(little)), big); + BOOST_TEST_EQ((be::convert_value(little)), native); + BOOST_TEST_EQ((be::convert_value(native)), big); + BOOST_TEST_EQ((be::convert_value(native)), native); // runtime order determination - BOOST_TEST_EQ((be::convert(big, be::order::big, be::order::big)), big); - BOOST_TEST_EQ((be::convert(little, be::order::little, be::order::little)), little); - BOOST_TEST_EQ((be::convert(native, be::order::native, be::order::native)), native); + BOOST_TEST_EQ((be::convert_value(big, be::order::big, be::order::big)), big); + BOOST_TEST_EQ((be::convert_value(little, be::order::little, be::order::little)), little); + BOOST_TEST_EQ((be::convert_value(native, be::order::native, be::order::native)), native); - BOOST_TEST_EQ((be::convert(big, be::order::big, be::order::little)), little); - BOOST_TEST_EQ((be::convert(big, be::order::big, be::order::native)), native); - BOOST_TEST_EQ((be::convert(little, be::order::little, be::order::big)), big); - BOOST_TEST_EQ((be::convert(little, be::order::little, be::order::native)), native); - BOOST_TEST_EQ((be::convert(native, be::order::native, be::order::big)), big); - BOOST_TEST_EQ((be::convert(native, be::order::native, be::order::little)), native); + BOOST_TEST_EQ((be::convert_value(big, be::order::big, be::order::little)), little); + BOOST_TEST_EQ((be::convert_value(big, be::order::big, be::order::native)), native); + BOOST_TEST_EQ((be::convert_value(little, be::order::little, be::order::big)), big); + BOOST_TEST_EQ((be::convert_value(little, be::order::little, be::order::native)), native); + BOOST_TEST_EQ((be::convert_value(native, be::order::native, be::order::big)), big); + BOOST_TEST_EQ((be::convert_value(native, be::order::native, be::order::little)), native); } } // unnamed namespace