Revamp reader/writer using concepts and get rid of all the typedef cruft

Author: sorsarre

bitreader/include/bitreader/bitreader-utils.hpp

@@ -25,98 +25,39 @@ namespace brcpp
     template<typename Enum>
     using fitting_integral = typename integral_by_size<sizeof(Enum)>::type;
 
-    struct binary_codec {};
-
-    template<bool cond, typename R>
-    using cond_if_t = std::enable_if_t<cond, R>;
-
-    template<typename T>
-    using check_unsigned_integral = std::bool_constant<std::is_unsigned_v<T> && std::is_integral_v<T>>;
-
-    template<typename T>
-    using check_signed_integral = std::bool_constant<std::is_signed_v<T> && std::is_integral_v<T>>;
-
-    template<typename T>
-    using check_integral = std::bool_constant<std::is_integral_v<T>>;
-
-    template<typename T>
-    using check_floating_point = std::bool_constant<std::is_floating_point_v<T>>;
-
-    template<typename T>
-    using check_bit_readable = std::bool_constant<std::is_floating_point_v<T> || std::is_integral_v<T>>;
-
-    template<typename T>
-    using check_binary_codec = std::bool_constant<std::is_base_of_v<binary_codec, T>>;
-
-    template<typename T>
-    using check_enum = std::bool_constant<std::is_enum_v<T>>;
-
-
-    template<typename T>
-    using if_unsigned_integral = std::enable_if_t<check_unsigned_integral<T>::value, T>;
-
-    template<typename T>
-    using if_signed_integral = std::enable_if_t<check_signed_integral<T>::value, T>;
-
-    template<typename T>
-    using if_integral = std::enable_if_t<check_integral<T>::value, T>;
+    struct binary_codec_base {};
 
     template<typename T>
-    using if_floating_point = std::enable_if_t<check_floating_point<T>::value, T>;
+    concept binary_codec = 
+        std::derived_from<T, binary_codec_base> &&
+        requires { typename T::value_type; };
 
     template<typename T>
-    using if_bit_readable = std::enable_if_t<check_bit_readable<T>::value, T>;
+    concept enumeration = std::is_enum_v<T>;
 
-    template<typename T>
-    using if_binary_codec = std::enable_if_t<check_binary_codec<T>::value, typename T::value_type>;
-
-    template<typename T>
-    using if_enum = std::enable_if_t<check_enum<T>::value, T>;
-
-
-    template<typename T>
-    using if_unsigned_integral_void = std::enable_if_t<check_unsigned_integral<T>::value, void>;
-
-    template<typename T>
-    using if_signed_integral_void = std::enable_if_t<check_signed_integral<T>::value, void>;
-
-    template<typename T>
-    using if_integral_void = std::enable_if_t<check_integral<T>::value, void>;
-
-    template<typename T>
-    using if_floating_point_void = std::enable_if_t<check_floating_point<T>::value, void>;
-
-    template<typename T>
-    using if_bit_readable_void = std::enable_if_t<check_bit_readable<T>::value, void>;
+    using std::integral;
+    using std::unsigned_integral;
+    using std::signed_integral;
+    using std::floating_point;
 
     template<typename T>
-    using if_binary_codec_void = std::enable_if_t<check_binary_codec<T>::value, void>;
-
-    template<typename T>
-    using if_enum_void = std::enable_if_t<check_enum<T>::value, void>;
+    struct bit_read_helper {};
 
     //--------------------------------------------------------------------------
-    template<typename T>
-    struct bit_read_helper
+    template<integral T>
+    struct bit_read_helper<T>
     {
         static constexpr const size_t max_bits = 8 * sizeof(T);
         static constexpr const size_t min_bits = 0;
         static constexpr const bool is_signed = std::is_signed_v<T>;
     };
 
     //--------------------------------------------------------------------------
-    template<typename T>
-    struct floating_point_bit_read_helper
+    template<floating_point T>
+    struct bit_read_helper<T>
     {
         static constexpr const size_t max_bits = 8 * sizeof(T);
         static constexpr const size_t min_bits = 8 * sizeof(T);
         static constexpr const bool is_signed = std::is_signed_v<T>;
     };
-
-    //--------------------------------------------------------------------------
-    template<> struct bit_read_helper<float>: floating_point_bit_read_helper<float> {};
-    template<> struct bit_read_helper<double>: floating_point_bit_read_helper<double> {};
-    template<> struct bit_read_helper<long double>: floating_point_bit_read_helper<long double> {};
-
-
 }

bitreader/include/bitreader/bitreader.hpp

@@ -2,6 +2,7 @@
 #include <cstdint>
 #include <cstddef>
 #include <cassert>
+#include <concepts>
 #include <stdexcept>
 #include <memory>
 
@@ -79,23 +80,23 @@ namespace brcpp {
          * @param bits  Number of bits to read
          * @return      The data read from the stream
          */
-        template<typename T>
-        if_integral<T> read(size_t bits)
+        template<integral T>
+        T read(size_t bits)
         {
             _validate_read_dynamic<T>(bits);
             T ret = T(0);
             _read(_state, bits, ret);
             return _sign_extend(ret, bits);
         }
 
-        template<typename T>
-        if_binary_codec<T> read()
+        template<binary_codec T>
+        T::value_type read()
         {
             return T::read(*this);
         }
 
-        template<typename T>
-        if_enum<T> read(size_t bits)
+        template<enumeration T>
+        T read(size_t bits)
         {
             using value_type = std::underlying_type_t<T>;
             auto val = static_cast<T>(read<value_type>(bits));
@@ -116,8 +117,8 @@ namespace brcpp {
          * @param bits  Number of bits to read
          * @return      The data read from the stream
          */
-        template<typename T>
-        if_integral<T> peek(size_t bits)
+        template<integral T>
+        T peek(size_t bits)
         {
             _validate_read_dynamic<T>(bits);
             T ret = T(0);
@@ -143,16 +144,16 @@ namespace brcpp {
         };
 
         //----------------------------------------------------------------------
-        template<typename T>
-        if_signed_integral<T> _sign_extend(T raw, size_t bits)
+        template<signed_integral T>
+        T _sign_extend(T raw, size_t bits)
         {
             const auto m = static_cast<T>(one<T> << (bits - 1));
             return (raw ^ m) - m;
         }
 
         //----------------------------------------------------------------------
-        template<typename T>
-        if_unsigned_integral<T> _sign_extend(T raw, size_t bits)
+        template<unsigned_integral T>
+        T _sign_extend(T raw, size_t bits)
         {
             return raw;
         }

bitreader/include/bitreader/bitwriter.hpp

@@ -52,8 +52,8 @@ namespace brcpp {
         }
 
         //----------------------------------------------------------------------
-        template<typename T>
-        if_integral_void<T> write(T data, size_t bits)
+        template<integral T>
+        void write(T data, size_t bits)
         {
             size_t written = 0;
             size_t to_write = bits;
@@ -75,17 +75,17 @@ namespace brcpp {
         }
 
         //----------------------------------------------------------------------
-        template<typename T>
-        if_enum_void<T> write(T data, size_t bits)
+        template<enumeration T>
+        void write(T data, size_t bits)
         {
             using data_t = std::underlying_type_t<T>;
             auto value = static_cast<data_t>(data);
             this->write(value, bits);
         }
 
         //----------------------------------------------------------------------
-        template<typename T>
-        if_binary_codec_void<T> write(typename T::value_type data)
+        template<binary_codec T>
+        void write(T::value_type data)
         {
             T::write(*this, data);
         }

bitreader/include/bitreader/codings/exp-golomb-k0.hpp

@@ -5,7 +5,7 @@
 namespace brcpp::ext
 {
     template<typename T>
-    struct exp_golomb_k0: public brcpp::binary_codec
+    struct exp_golomb_k0: public brcpp::binary_codec_base
     {
         using value_type = T;
 

bitreader/include/bitreader/codings/string-nullterm.hpp

@@ -5,7 +5,7 @@
 
 namespace brcpp::ext
 {
-    struct string_nullterm: public brcpp::binary_codec
+    struct string_nullterm: public brcpp::binary_codec_base
     {
         using value_type = std::string;