boostorg/endian
1
0
Fork 1
mirror of https://github.com/boostorg/endian.git synced 2025-08-01 05:24:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

Change name convert_bytes to convert. Given the namespace, template parameters, and function arguments, it is obvious what is being converted, and "bytes" is too low level for this function.

Browse Source
This commit is contained in:
Beman
2013-05-12 07:25:12 -04:00
parent 3877219925
commit 50c1a27386
2 changed files with 95 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
include/boost/endian/converters.hpp
View File

@@ -61,7 +61,7 @@ namespace endian
// compile-time generic byte order conversion
template <BOOST_SCOPED_ENUM(order) From, BOOST_SCOPED_ENUM(order) To, class T>
T convert_bytes(T from) BOOST_NOEXCEPT;
T convert(T from) BOOST_NOEXCEPT;
// runtime actual byte-order determination
inline BOOST_SCOPED_ENUM(order) actual_order(BOOST_SCOPED_ENUM(order) o) BOOST_NOEXCEPT;
@@ -69,8 +69,8 @@ namespace endian
// runtime byte-order conversion
template <class T>
T convert_bytes(T from, BOOST_SCOPED_ENUM(order) from_order,
BOOST_SCOPED_ENUM(order) to_order) BOOST_NOEXCEPT;
T convert(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
@@ -201,93 +201,93 @@ namespace endian
# endif
}
template<> inline int16_t convert_bytes<order::big, order::big>(int16_t x) BOOST_NOEXCEPT {return x;}
template<> inline int16_t convert_bytes<order::little, order::little>(int16_t x) BOOST_NOEXCEPT {return x;}
template<> inline int16_t convert_bytes<order::native, order::native>(int16_t x) BOOST_NOEXCEPT {return x;}
template<> inline int16_t convert<order::big, order::big>(int16_t x) BOOST_NOEXCEPT {return x;}
template<> inline int16_t convert<order::little, order::little>(int16_t x) BOOST_NOEXCEPT {return x;}
template<> inline int16_t convert<order::native, order::native>(int16_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint16_t convert_bytes<order::big, order::big>(uint16_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint16_t convert_bytes<order::little, order::little>(uint16_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint16_t convert_bytes<order::native, order::native>(uint16_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint16_t convert<order::big, order::big>(uint16_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint16_t convert<order::little, order::little>(uint16_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint16_t convert<order::native, order::native>(uint16_t x) BOOST_NOEXCEPT {return x;}
template<> inline int32_t convert_bytes<order::big, order::big>(int32_t x) BOOST_NOEXCEPT {return x;}
template<> inline int32_t convert_bytes<order::little, order::little>(int32_t x) BOOST_NOEXCEPT {return x;}
template<> inline int32_t convert_bytes<order::native, order::native>(int32_t x) BOOST_NOEXCEPT {return x;}
template<> inline int32_t convert<order::big, order::big>(int32_t x) BOOST_NOEXCEPT {return x;}
template<> inline int32_t convert<order::little, order::little>(int32_t x) BOOST_NOEXCEPT {return x;}
template<> inline int32_t convert<order::native, order::native>(int32_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint32_t convert_bytes<order::big, order::big>(uint32_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint32_t convert_bytes<order::little, order::little>(uint32_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint32_t convert_bytes<order::native, order::native>(uint32_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint32_t convert<order::big, order::big>(uint32_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint32_t convert<order::little, order::little>(uint32_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint32_t convert<order::native, order::native>(uint32_t x) BOOST_NOEXCEPT {return x;}
template<> inline int64_t convert_bytes<order::big, order::big>(int64_t x) BOOST_NOEXCEPT {return x;}
template<> inline int64_t convert_bytes<order::little, order::little>(int64_t x) BOOST_NOEXCEPT {return x;}
template<> inline int64_t convert_bytes<order::native, order::native>(int64_t x) BOOST_NOEXCEPT {return x;}
template<> inline int64_t convert<order::big, order::big>(int64_t x) BOOST_NOEXCEPT {return x;}
template<> inline int64_t convert<order::little, order::little>(int64_t x) BOOST_NOEXCEPT {return x;}
template<> inline int64_t convert<order::native, order::native>(int64_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint64_t convert_bytes<order::big, order::big>(uint64_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint64_t convert_bytes<order::little, order::little>(uint64_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint64_t convert_bytes<order::native, order::native>(uint64_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint64_t convert<order::big, order::big>(uint64_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint64_t convert<order::little, order::little>(uint64_t x) BOOST_NOEXCEPT {return x;}
template<> inline uint64_t convert<order::native, order::native>(uint64_t x) BOOST_NOEXCEPT {return x;}
template<> inline float convert_bytes<order::big, order::big>(float x) BOOST_NOEXCEPT {return x;}
template<> inline float convert_bytes<order::little, order::little>(float x) BOOST_NOEXCEPT {return x;}
template<> inline float convert_bytes<order::native, order::native>(float x) BOOST_NOEXCEPT {return x;}
template<> inline float convert<order::big, order::big>(float x) BOOST_NOEXCEPT {return x;}
template<> inline float convert<order::little, order::little>(float x) BOOST_NOEXCEPT {return x;}
template<> inline float convert<order::native, order::native>(float x) BOOST_NOEXCEPT {return x;}
template<> inline double convert_bytes<order::big, order::big>(double x) BOOST_NOEXCEPT {return x;}
template<> inline double convert_bytes<order::little, order::little>(double x) BOOST_NOEXCEPT {return x;}
template<> inline double convert_bytes<order::native, order::native>(double x) BOOST_NOEXCEPT {return x;}
template<> inline double convert<order::big, order::big>(double x) BOOST_NOEXCEPT {return x;}
template<> inline double convert<order::little, order::little>(double x) BOOST_NOEXCEPT {return x;}
template<> inline double convert<order::native, order::native>(double x) BOOST_NOEXCEPT {return x;}
template<> inline int16_t convert_bytes<order::big, order::little>(int16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int16_t convert_bytes<order::big, order::native>(int16_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int16_t convert_bytes<order::little, order::big>(int16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int16_t convert_bytes<order::little, order::native>(int16_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int16_t convert_bytes<order::native, order::big>(int16_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int16_t convert_bytes<order::native, order::little>(int16_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int16_t convert<order::big, order::little>(int16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int16_t convert<order::big, order::native>(int16_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int16_t convert<order::little, order::big>(int16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int16_t convert<order::little, order::native>(int16_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int16_t convert<order::native, order::big>(int16_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int16_t convert<order::native, order::little>(int16_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint16_t convert_bytes<order::big, order::little>(uint16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint16_t convert_bytes<order::big, order::native>(uint16_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint16_t convert_bytes<order::little, order::big>(uint16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint16_t convert_bytes<order::little, order::native>(uint16_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint16_t convert_bytes<order::native, order::big>(uint16_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint16_t convert_bytes<order::native, order::little>(uint16_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint16_t convert<order::big, order::little>(uint16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint16_t convert<order::big, order::native>(uint16_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint16_t convert<order::little, order::big>(uint16_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint16_t convert<order::little, order::native>(uint16_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint16_t convert<order::native, order::big>(uint16_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint16_t convert<order::native, order::little>(uint16_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int32_t convert_bytes<order::big, order::little>(int32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int32_t convert_bytes<order::big, order::native>(int32_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int32_t convert_bytes<order::little, order::big>(int32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int32_t convert_bytes<order::little, order::native>(int32_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int32_t convert_bytes<order::native, order::big>(int32_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int32_t convert_bytes<order::native, order::little>(int32_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int32_t convert<order::big, order::little>(int32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int32_t convert<order::big, order::native>(int32_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int32_t convert<order::little, order::big>(int32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int32_t convert<order::little, order::native>(int32_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int32_t convert<order::native, order::big>(int32_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int32_t convert<order::native, order::little>(int32_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint32_t convert_bytes<order::big, order::little>(uint32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint32_t convert_bytes<order::big, order::native>(uint32_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint32_t convert_bytes<order::little, order::big>(uint32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint32_t convert_bytes<order::little, order::native>(uint32_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint32_t convert_bytes<order::native, order::big>(uint32_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint32_t convert_bytes<order::native, order::little>(uint32_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint32_t convert<order::big, order::little>(uint32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint32_t convert<order::big, order::native>(uint32_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint32_t convert<order::little, order::big>(uint32_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint32_t convert<order::little, order::native>(uint32_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint32_t convert<order::native, order::big>(uint32_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint32_t convert<order::native, order::little>(uint32_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int64_t convert_bytes<order::big, order::little>(int64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int64_t convert_bytes<order::big, order::native>(int64_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int64_t convert_bytes<order::little, order::big>(int64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int64_t convert_bytes<order::little, order::native>(int64_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int64_t convert_bytes<order::native, order::big>(int64_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int64_t convert_bytes<order::native, order::little>(int64_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int64_t convert<order::big, order::little>(int64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int64_t convert<order::big, order::native>(int64_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int64_t convert<order::little, order::big>(int64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline int64_t convert<order::little, order::native>(int64_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline int64_t convert<order::native, order::big>(int64_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline int64_t convert<order::native, order::little>(int64_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint64_t convert_bytes<order::big, order::little>(uint64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint64_t convert_bytes<order::big, order::native>(uint64_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint64_t convert_bytes<order::little, order::big>(uint64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint64_t convert_bytes<order::little, order::native>(uint64_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint64_t convert_bytes<order::native, order::big>(uint64_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint64_t convert_bytes<order::native, order::little>(uint64_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint64_t convert<order::big, order::little>(uint64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint64_t convert<order::big, order::native>(uint64_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint64_t convert<order::little, order::big>(uint64_t x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline uint64_t convert<order::little, order::native>(uint64_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline uint64_t convert<order::native, order::big>(uint64_t x) BOOST_NOEXCEPT {return big(x);}
template<> inline uint64_t convert<order::native, order::little>(uint64_t x) BOOST_NOEXCEPT {return little(x);}
template<> inline float convert_bytes<order::big, order::little>(float x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline float convert_bytes<order::big, order::native>(float x) BOOST_NOEXCEPT {return big(x);}
template<> inline float convert_bytes<order::little, order::big>(float x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline float convert_bytes<order::little, order::native>(float x) BOOST_NOEXCEPT {return little(x);}
template<> inline float convert_bytes<order::native, order::big>(float x) BOOST_NOEXCEPT {return big(x);}
template<> inline float convert_bytes<order::native, order::little>(float x) BOOST_NOEXCEPT {return little(x);}
template<> inline float convert<order::big, order::little>(float x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline float convert<order::big, order::native>(float x) BOOST_NOEXCEPT {return big(x);}
template<> inline float convert<order::little, order::big>(float x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline float convert<order::little, order::native>(float x) BOOST_NOEXCEPT {return little(x);}
template<> inline float convert<order::native, order::big>(float x) BOOST_NOEXCEPT {return big(x);}
template<> inline float convert<order::native, order::little>(float x) BOOST_NOEXCEPT {return little(x);}
template<> inline double convert_bytes<order::big, order::little>(double x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline double convert_bytes<order::big, order::native>(double x) BOOST_NOEXCEPT {return big(x);}
template<> inline double convert_bytes<order::little, order::big>(double x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline double convert_bytes<order::little, order::native>(double x) BOOST_NOEXCEPT {return little(x);}
template<> inline double convert_bytes<order::native, order::big>(double x) BOOST_NOEXCEPT {return big(x);}
template<> inline double convert_bytes<order::native, order::little>(double x) BOOST_NOEXCEPT {return little(x);}
template<> inline double convert<order::big, order::little>(double x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline double convert<order::big, order::native>(double x) BOOST_NOEXCEPT {return big(x);}
template<> inline double convert<order::little, order::big>(double x) BOOST_NOEXCEPT {return reverse_bytes(x);}
template<> inline double convert<order::little, order::native>(double x) BOOST_NOEXCEPT {return little(x);}
template<> inline double convert<order::native, order::big>(double x) BOOST_NOEXCEPT {return big(x);}
template<> inline double convert<order::native, order::little>(double x) BOOST_NOEXCEPT {return little(x);}
inline BOOST_SCOPED_ENUM(order) actual_order(BOOST_SCOPED_ENUM(order) o) BOOST_NOEXCEPT
{
@@ -301,8 +301,8 @@ namespace endian
}
template <class T>
T convert_bytes(T from, BOOST_SCOPED_ENUM(order) from_order,
BOOST_SCOPED_ENUM(order) to_order) BOOST_NOEXCEPT
T convert(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);

36
test/converter_test.cpp
View File

@@ -211,29 +211,29 @@ namespace
// compile time order determination
BOOST_TEST_EQ((be::convert_bytes<be::order::big, be::order::big>(big)), big);
BOOST_TEST_EQ((be::convert_bytes<be::order::little, be::order::little>(little)), little);
BOOST_TEST_EQ((be::convert_bytes<be::order::native, be::order::native>(native)), native);
BOOST_TEST_EQ((be::convert<be::order::big, be::order::big>(big)), big);
BOOST_TEST_EQ((be::convert<be::order::little, be::order::little>(little)), little);
BOOST_TEST_EQ((be::convert<be::order::native, be::order::native>(native)), native);
BOOST_TEST_EQ((be::convert_bytes<be::order::big, be::order::little>(big)), little);
BOOST_TEST_EQ((be::convert_bytes<be::order::big, be::order::native>(big)), native);
BOOST_TEST_EQ((be::convert_bytes<be::order::little, be::order::big>(little)), big);
BOOST_TEST_EQ((be::convert_bytes<be::order::little, be::order::native>(little)), native);
BOOST_TEST_EQ((be::convert_bytes<be::order::native, be::order::big>(native)), big);
BOOST_TEST_EQ((be::convert_bytes<be::order::native, be::order::little>(native)), native);
BOOST_TEST_EQ((be::convert<be::order::big, be::order::little>(big)), little);
BOOST_TEST_EQ((be::convert<be::order::big, be::order::native>(big)), native);
BOOST_TEST_EQ((be::convert<be::order::little, be::order::big>(little)), big);
BOOST_TEST_EQ((be::convert<be::order::little, be::order::native>(little)), native);
BOOST_TEST_EQ((be::convert<be::order::native, be::order::big>(native)), big);
BOOST_TEST_EQ((be::convert<be::order::native, be::order::little>(native)), native);
// runtime order determination
BOOST_TEST_EQ((be::convert_bytes(big, be::order::big, be::order::big)), big);
BOOST_TEST_EQ((be::convert_bytes(little, be::order::little, be::order::little)), little);
BOOST_TEST_EQ((be::convert_bytes(native, be::order::native, be::order::native)), native);
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_bytes(big, be::order::big, be::order::little)), little);
BOOST_TEST_EQ((be::convert_bytes(big, be::order::big, be::order::native)), native);
BOOST_TEST_EQ((be::convert_bytes(little, be::order::little, be::order::big)), big);
BOOST_TEST_EQ((be::convert_bytes(little, be::order::little, be::order::native)), native);
BOOST_TEST_EQ((be::convert_bytes(native, be::order::native, be::order::big)), big);
BOOST_TEST_EQ((be::convert_bytes(native, be::order::native, be::order::little)), 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);
}
} // unnamed namespace