From 854c27939ac144a26d22b09f0125872b3d21b578 Mon Sep 17 00:00:00 2001
From: Beman <bdawes@acm.org>
Date: Sun, 12 May 2013 07:52:42 -0400
Subject: [PATCH] Change name of conditional conversion functions to big_endian
 and little_endian.

---
 include/boost/endian/converters.hpp | 72 ++++++++++++++---------------
 test/converter_test.cpp             | 40 ++++++++--------
 2 files changed, 56 insertions(+), 56 deletions(-)

diff --git a/include/boost/endian/converters.hpp b/include/boost/endian/converters.hpp
index 8e3cba4..72cb7b4 100644
--- a/include/boost/endian/converters.hpp
+++ b/include/boost/endian/converters.hpp
@@ -50,13 +50,13 @@ namespace endian
   //  reverse bytes unless native endianness is big
   //  possible names: reverse_unless_native_big, reverse_bytes_unless_big, reverse_unless_big
   template <class T>
-  inline T big(T x) BOOST_NOEXCEPT;    
+  inline T big_endian(T x) BOOST_NOEXCEPT;    
     //  Return: x if native endian order is big, otherwise reverse_bytes(x)
 
   //  reverse bytes unless native endianness is little
   //  possible names: reverse_unless_native_little, reverse_bytes_unless_little, reverse_unless_little
   template <class T>
-  inline T little(T x) BOOST_NOEXCEPT; 
+  inline T little_endian(T x) BOOST_NOEXCEPT; 
     //  Return: x if native endian order is little, otherwise reverse_bytes(x);
 
   //  compile-time generic byte order conversion
@@ -182,7 +182,7 @@ namespace endian
   }
 
   template <class T>
-  inline T big(T x) BOOST_NOEXCEPT
+  inline T big_endian(T x) BOOST_NOEXCEPT
   {
 #   ifdef BOOST_BIG_ENDIAN
       return x;
@@ -192,7 +192,7 @@ namespace endian
   }
 
   template <class T>
-  inline T little(T x) BOOST_NOEXCEPT    
+  inline T little_endian(T x) BOOST_NOEXCEPT    
   {
 #   ifdef BOOST_LITTLE_ENDIAN
       return x;
@@ -234,60 +234,60 @@ namespace endian
   template<> inline double convert<order::native, order::native>(double x) BOOST_NOEXCEPT {return 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::big, order::native>(int16_t x) BOOST_NOEXCEPT {return big_endian(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 int16_t convert<order::little, order::native>(int16_t x) BOOST_NOEXCEPT {return little_endian(x);}
+  template<> inline int16_t convert<order::native, order::big>(int16_t x) BOOST_NOEXCEPT {return big_endian(x);}
+  template<> inline int16_t convert<order::native, order::little>(int16_t x) BOOST_NOEXCEPT {return little_endian(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::big, order::native>(uint16_t x) BOOST_NOEXCEPT {return big_endian(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 uint16_t convert<order::little, order::native>(uint16_t x) BOOST_NOEXCEPT {return little_endian(x);}
+  template<> inline uint16_t convert<order::native, order::big>(uint16_t x) BOOST_NOEXCEPT {return big_endian(x);}
+  template<> inline uint16_t convert<order::native, order::little>(uint16_t x) BOOST_NOEXCEPT {return little_endian(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::big, order::native>(int32_t x) BOOST_NOEXCEPT {return big_endian(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 int32_t convert<order::little, order::native>(int32_t x) BOOST_NOEXCEPT {return little_endian(x);}
+  template<> inline int32_t convert<order::native, order::big>(int32_t x) BOOST_NOEXCEPT {return big_endian(x);}
+  template<> inline int32_t convert<order::native, order::little>(int32_t x) BOOST_NOEXCEPT {return little_endian(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::big, order::native>(uint32_t x) BOOST_NOEXCEPT {return big_endian(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 uint32_t convert<order::little, order::native>(uint32_t x) BOOST_NOEXCEPT {return little_endian(x);}
+  template<> inline uint32_t convert<order::native, order::big>(uint32_t x) BOOST_NOEXCEPT {return big_endian(x);}
+  template<> inline uint32_t convert<order::native, order::little>(uint32_t x) BOOST_NOEXCEPT {return little_endian(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::big, order::native>(int64_t x) BOOST_NOEXCEPT {return big_endian(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 int64_t convert<order::little, order::native>(int64_t x) BOOST_NOEXCEPT {return little_endian(x);}
+  template<> inline int64_t convert<order::native, order::big>(int64_t x) BOOST_NOEXCEPT {return big_endian(x);}
+  template<> inline int64_t convert<order::native, order::little>(int64_t x) BOOST_NOEXCEPT {return little_endian(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::big, order::native>(uint64_t x) BOOST_NOEXCEPT {return big_endian(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 uint64_t convert<order::little, order::native>(uint64_t x) BOOST_NOEXCEPT {return little_endian(x);}
+  template<> inline uint64_t convert<order::native, order::big>(uint64_t x) BOOST_NOEXCEPT {return big_endian(x);}
+  template<> inline uint64_t convert<order::native, order::little>(uint64_t x) BOOST_NOEXCEPT {return little_endian(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::big, order::native>(float x) BOOST_NOEXCEPT {return big_endian(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 float convert<order::little, order::native>(float x) BOOST_NOEXCEPT {return little_endian(x);}
+  template<> inline float convert<order::native, order::big>(float x) BOOST_NOEXCEPT {return big_endian(x);}
+  template<> inline float convert<order::native, order::little>(float x) BOOST_NOEXCEPT {return little_endian(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::big, order::native>(double x) BOOST_NOEXCEPT {return big_endian(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);}
+  template<> inline double convert<order::little, order::native>(double x) BOOST_NOEXCEPT {return little_endian(x);}
+  template<> inline double convert<order::native, order::big>(double x) BOOST_NOEXCEPT {return big_endian(x);}
+  template<> inline double convert<order::native, order::little>(double x) BOOST_NOEXCEPT {return little_endian(x);}
 
   inline BOOST_SCOPED_ENUM(order) actual_order(BOOST_SCOPED_ENUM(order) o) BOOST_NOEXCEPT
   {
diff --git a/test/converter_test.cpp b/test/converter_test.cpp
index 125e0fa..408a90b 100644
--- a/test/converter_test.cpp
+++ b/test/converter_test.cpp
@@ -180,33 +180,33 @@ namespace
     BOOST_TEST_EQ(be::reverse_bytes<T>(big), little);
     BOOST_TEST_EQ(be::reverse_bytes<T>(little), big);
 
-    BOOST_TEST_EQ(be::big(native), big);
-    BOOST_TEST_EQ(be::little(native), little);
-    BOOST_TEST_EQ(be::big(be::big(native)), native);
-    BOOST_TEST_EQ(be::big(be::big(big)), big);
-    BOOST_TEST_EQ(be::big(be::big(little)), little);
-    BOOST_TEST_EQ(be::little(be::little(native)), native);
-    BOOST_TEST_EQ(be::little(be::little(big)), big);
-    BOOST_TEST_EQ(be::little(be::little(little)), little);
+    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);
 
 # ifdef BOOST_BIG_ENDIAN
     BOOST_TEST_EQ(be::reverse_bytes(native), little);
     BOOST_TEST_EQ(be::reverse_bytes<T>(native), little);
-    BOOST_TEST_EQ(be::big(big), big);
-    BOOST_TEST_EQ(be::big<T>(big), big);
-    BOOST_TEST_EQ(be::big(little), little);
-    BOOST_TEST_EQ(be::big<T>(little), little);
-    BOOST_TEST_EQ(be::big(native), little);
-    BOOST_TEST_EQ(be::big<T>(native), little);
+    BOOST_TEST_EQ(be::big_endian(big), big);
+    BOOST_TEST_EQ(be::big_endian<T>(big), big);
+    BOOST_TEST_EQ(be::big_endian(little), little);
+    BOOST_TEST_EQ(be::big_endian<T>(little), little);
+    BOOST_TEST_EQ(be::big_endian(native), little);
+    BOOST_TEST_EQ(be::big_endian<T>(native), little);
 # else
     BOOST_TEST_EQ(be::reverse_bytes(native), big);
     BOOST_TEST_EQ(be::reverse_bytes<T>(native), big);
-    BOOST_TEST_EQ(be::big(big), little);
-    BOOST_TEST_EQ(be::big<T>(big), little);
-    BOOST_TEST_EQ(be::big(little), big);
-    BOOST_TEST_EQ(be::big<T>(little), big);
-    BOOST_TEST_EQ(be::big(native), big);
-    BOOST_TEST_EQ(be::big<T>(native), big);
+    BOOST_TEST_EQ(be::big_endian(big), little);
+    BOOST_TEST_EQ(be::big_endian<T>(big), little);
+    BOOST_TEST_EQ(be::big_endian(little), big);
+    BOOST_TEST_EQ(be::big_endian<T>(little), big);
+    BOOST_TEST_EQ(be::big_endian(native), big);
+    BOOST_TEST_EQ(be::big_endian<T>(native), big);
 # endif
 
     //  compile time order determination