From 50c1a273869dc505be5a2cbee244ade86fda0268 Mon Sep 17 00:00:00 2001
From: Beman <bdawes@acm.org>
Date: Sun, 12 May 2013 07:25:12 -0400
Subject: [PATCH] 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.

---
 include/boost/endian/converters.hpp | 154 ++++++++++++++--------------
 test/converter_test.cpp             |  36 +++----
 2 files changed, 95 insertions(+), 95 deletions(-)

diff --git a/include/boost/endian/converters.hpp b/include/boost/endian/converters.hpp
index e670b39..8e3cba4 100644
--- a/include/boost/endian/converters.hpp
+++ b/include/boost/endian/converters.hpp
@@ -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);
diff --git a/test/converter_test.cpp b/test/converter_test.cpp
index 9340234..125e0fa 100644
--- a/test/converter_test.cpp
+++ b/test/converter_test.cpp
@@ -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