Change byteswap() to function template, returning parameter type

Also use unsigned type normalization and catch non-integral types via static_assert

Author: martinmoene

include/nonstd/bit.hpp

@@ -387,6 +387,31 @@ struct same_as : std11::integral_constant<bool, std11::is_same<T,U>::value && st
 
 } // namespace std20
 
+// Other detail:
+
+// make sure all unsigned types are covered, see
+// http://ithare.com/c-on-using-int_t-as-overload-and-template-parameters/
+
+template< size_t N > struct uint_by_size;
+template<> struct uint_by_size< 8> { typedef std11::uint8_t  type; };
+template<> struct uint_by_size<16> { typedef std11::uint16_t type; };
+template<> struct uint_by_size<32> { typedef std11::uint32_t type; };
+#if bit_CPP11_OR_GREATER
+template<> struct uint_by_size<64> { typedef std11::uint64_t type; };
+#endif
+
+template< typename T >
+struct normalized_uint_type
+{
+    typedef typename uint_by_size< CHAR_BIT * sizeof( T ) >::type type;
+
+#if bit_HAVE( STATIC_ASSERT )
+    static_assert( std::is_integral<T>::value, "integral type required.");
+    static_assert( std11::is_unsigned<type>::value, "unsigned type result expected.");
+    static_assert( sizeof( type ) == sizeof( T ), "size of determined type differs from type derived from.");
+#endif
+};
+
 //
 // For reference:
 //
@@ -449,30 +474,36 @@ bit_cast( From const & src ) bit_noexcept
 
 // 26.5.4, byteswap (C++23, p1272)
 
-inline bit_constexpr std11::uint8_t byteswap ( std11::uint8_t value ) bit_noexcept
+inline bit_constexpr std11::uint8_t byteswap_( std11::uint8_t value ) bit_noexcept
 {
     return value;
 }
 
-inline /*bit_constexpr*/ std11::uint16_t byteswap ( std11::uint16_t value ) bit_noexcept
+inline /*bit_constexpr*/ std11::uint16_t byteswap_( std11::uint16_t value ) bit_noexcept
 {
     return bit_byteswap16( value );
 }
 
-inline /*bit_constexpr*/ std11::uint32_t byteswap ( std11::uint32_t value ) bit_noexcept
+inline /*bit_constexpr*/ std11::uint32_t byteswap_( std11::uint32_t value ) bit_noexcept
 {
     return bit_byteswap32( value );
 }
 
 #if bit_CPP11_OR_GREATER
 
-inline /*bit_constexpr*/ std11::uint64_t byteswap ( std11::uint64_t value ) bit_noexcept
+inline /*bit_constexpr*/ std11::uint64_t byteswap_( std11::uint64_t value ) bit_noexcept
 {
     return bit_byteswap64( value );
 }
 
 #endif
 
+template< typename T >
+inline /*bit_constexpr*/ T byteswap( T v ) bit_noexcept
+{
+    return static_cast<T>( byteswap_( static_cast< typename normalized_uint_type<T>::type >( v ) ) );
+}
+
 // 26.5.6, rotating
 
 // clang 3.5 - 3.8: Infinite recursive template instantiation when using Clang while GCC works fine?
@@ -771,29 +802,6 @@ typedef std11::integral_constant<int, static_cast<int>(endian::big   )> big_endi
 typedef std11::integral_constant<int, static_cast<int>(endian::little)> little_endian_type;
 typedef std11::integral_constant<int, static_cast<int>(endian::native)> native_endian_type;
 
-// make sure all unsigned types are covered, see
-// http://ithare.com/c-on-using-int_t-as-overload-and-template-parameters/
-
-template< size_t N > struct uint_by_size;
-template<> struct uint_by_size< 8> { typedef std11::uint8_t  type; };
-template<> struct uint_by_size<16> { typedef std11::uint16_t type; };
-template<> struct uint_by_size<32> { typedef std11::uint32_t type; };
-#if bit_CPP11_OR_GREATER
-template<> struct uint_by_size<64> { typedef std11::uint64_t type; };
-#endif
-
-template< typename T >
-struct normalized_uint_type
-{
-    typedef typename uint_by_size< CHAR_BIT * sizeof( T ) >::type type;
-
-#if bit_HAVE( STATIC_ASSERT )
-    static_assert( sizeof( type ) == sizeof( T ), "");
-    static_assert( std::is_integral<T>::value, "");
-    static_assert( std11::is_unsigned<type>::value, "");
-#endif
-};
-
 // to big endian (implementation):
 
 inline std11::uint8_t to_big_endian_( std11::uint8_t v, little_endian_type )

test/bit.t.cpp

@@ -11,6 +11,10 @@
 #include <climits>      // CHAR_BIT, when bit_USES_STD_BIT
 #include <iostream>
 
+#ifndef  bit_COMPILE_TIME_TEST
+# define bit_COMPILE_TIME_TEST  0
+#endif
+
 #define dimension_of(a)  ( sizeof(a) / sizeof(0[a]) )
 
 #if bit_CPP11_90
@@ -89,10 +93,17 @@ CASE( "bit_cast<>(): successfully roundtrips uint64_t via double" " [bit.cast]"
 CASE( "byteswap(): allow to swap bytes in 1, 2, 4, 8-byte integrals" " [bit.byteswap]" )
 {
 #if bit_HAVE_BYTESWAP
+#if bit_COMPILE_TIME_TEST
+    EXPECT( byteswap( float   (0x0  )                 ) ==  float   (0x0    )                );
+#endif
+    EXPECT( byteswap( int8_t  (0x12 )                 ) ==  int8_t  (0x12   )                );
     EXPECT( byteswap( uint8_t (0x12u)                 ) ==  uint8_t (0x12u  )                );
+    EXPECT( byteswap( int16_t (0x1234 )               ) ==  int16_t (0x3412 )                );
     EXPECT( byteswap( uint16_t(0x1234u)               ) ==  uint16_t(0x3412u)                );
+    EXPECT( byteswap( int32_t (0x12345678l )          ) ==  uint32_t(0x78563412l )           );
     EXPECT( byteswap( uint32_t(0x12345678ul)          ) ==  uint32_t(0x78563412ul)           );
 #if bit_CPP11_OR_GREATER
+    EXPECT( byteswap( int64_t (0x12345678AABBCCDDll ) ) ==  int64_t (0xDDCCBBAA78563412ll  ) );
     EXPECT( byteswap( uint64_t(0x12345678AABBCCDDull) ) ==  uint64_t(0xDDCCBBAA78563412ull ) );
 #endif
 #else