Merge pull request #542 from beached/v2

Updates around bit_count and arith_traits

Author: beached

CMakeLists.txt

@@ -9,7 +9,7 @@
 cmake_minimum_required( VERSION 3.14 )
 
 project( "daw-header-libraries"
-         VERSION "2.123.1"
+         VERSION "2.123.2"
          DESCRIPTION "Various headers"
          HOMEPAGE_URL "https://github.com/beached/header_libraries"
          LANGUAGES C CXX

include/daw/daw_arith_traits.h

@@ -193,7 +193,7 @@ namespace daw {
 	inline constexpr bool is_system_integral_v = is_system_integral<T>::value;
 
 	template<typename T, std::size_t BitSize>
-	using is_same_size = std::bool_constant<( ( sizeof( T ) * 8 ) == BitSize )>;
+	using is_same_size = std::bool_constant<( bit_count_v<T> == BitSize )>;
 
 	template<typename T, std::size_t BitSize>
 	inline constexpr bool is_same_size_v = is_same_size<T, BitSize>::value;

include/daw/daw_benchmark.h

@@ -8,11 +8,12 @@
 
 #pragma once
 
-#include "ciso646.h"
-#include "daw_do_not_optimize.h"
-#include "daw_expected.h"
-#include "daw_move.h"
-#include "daw_string_view.h"
+#include "daw/ciso646.h"
+#include "daw/daw_arith_traits.h"
+#include "daw/daw_do_not_optimize.h"
+#include "daw/daw_expected.h"
+#include "daw/daw_move.h"
+#include "daw/daw_string_view.h"
 
 #include <array>
 #include <chrono>
@@ -209,7 +210,7 @@ namespace daw {
 		static_assert( std::is_invocable_v<Test, Args...>,
 		               "Unable to call Test with provided Args" );
 
-		double base_time = ( std::numeric_limits<double>::max )( );
+		double base_time = max_value<double>;
 		{
 			for( size_t n = 0; n < 1000; ++n ) {
 				daw::do_not_optimize( args... );
@@ -230,7 +231,7 @@ namespace daw {
 				}
 			}
 		}
-		double min_time = ( std::numeric_limits<double>::max )( );
+		double min_time = max_value<double>;
 		double max_time = 0.0;
 
 		auto const total_start = std::chrono::steady_clock::now( );
@@ -321,7 +322,7 @@ namespace daw {
 		  "Validator must be callable with the results of Function" );
 
 		auto results = std::array<double, Runs>{ };
-		double base_time = ( std::numeric_limits<double>::max )( );
+		double base_time = max_value<double>;
 		{
 			for( size_t n = 0; n < 1000; ++n ) {
 				int a = 0;
@@ -371,7 +372,7 @@ namespace daw {
 		static_assert( Runs > 0 );
 		static_assert( std::is_invocable_v<Test, Args...>,
 		               "Unable to call Test with provided Args" );
-		double base_time = ( std::numeric_limits<double>::max )( );
+		double base_time = max_value<double>;
 		{
 			for( size_t n = 0; n < 1000; ++n ) {
 				intmax_t a = 0;
@@ -390,7 +391,7 @@ namespace daw {
 				}
 			}
 		}
-		double min_time = ( std::numeric_limits<double>::max )( );
+		double min_time = max_value<double>;
 		double max_time = 0.0;
 
 		auto const total_start = std::chrono::steady_clock::now( );
@@ -481,8 +482,7 @@ namespace daw {
 		static_assert( std::is_invocable_v<Function, Args...>,
 		               "Unable to call Test with provided Args" );
 
-		auto base_time =
-		  std::chrono::nanoseconds( ( std::numeric_limits<long long>::max )( ) );
+		auto base_time = std::chrono::nanoseconds( max_value<long long> );
 		{
 			for( size_t n = 0; n < 1000; ++n ) {
 				daw::do_not_optimize( args... );
@@ -538,8 +538,7 @@ namespace daw {
 		  std::is_invocable_v<Validator, std::invoke_result_t<Function, Args...>>,
 		  "Validator must be callable with the results of Function" );
 
-		auto base_time =
-		  std::chrono::nanoseconds( ( std::numeric_limits<long long>::max )( ) );
+		auto base_time = std::chrono::nanoseconds( max_value<long long> );
 		{
 			for( size_t n = 0; n < 1000; ++n ) {
 				daw::do_not_optimize( args... );

include/daw/daw_bit.h

@@ -8,41 +8,43 @@
 
 #pragma once
 
-#include "ciso646.h"
-#include "daw_traits.h"
-#include "daw_utility.h"
+#include "daw/ciso646.h"
+#include "daw/daw_arith_traits.h"
+#include "daw/daw_bit_count.h"
+#include "daw/daw_traits.h"
+#include "daw/daw_utility.h"
 
+#include <cstddef>
 #include <limits>
+#include <type_traits>
 
 namespace daw {
 	template<typename T>
 	[[deprecated( "Use mask_msb" )]] constexpr T
 	get_left_mask( size_t left_zero_bits ) noexcept {
-		return static_cast<T>( ( std::numeric_limits<T>::max )( ) >>
-		                       left_zero_bits );
+		return static_cast<T>( max_value<T> >> left_zero_bits );
 	}
 
 	template<typename T>
 	constexpr T mask_msb( size_t bit_count ) noexcept {
 		if( bit_count >= daw::bsizeof<T> ) {
 			return static_cast<T>( 0 );
 		}
-		return static_cast<T>( ( std::numeric_limits<T>::max )( ) >> bit_count );
+		return static_cast<T>( max_value<T> >> bit_count );
 	}
 
 	template<typename T>
 	[[deprecated( "Use mask_lsb" )]] constexpr T
 	get_right_mask( size_t right_zero_bits ) noexcept {
-		return static_cast<T>( ( std::numeric_limits<T>::max )( )
-		                       << right_zero_bits );
+		return static_cast<T>( max_value<T> << right_zero_bits );
 	}
 
 	template<typename T>
 	constexpr T mask_lsb( size_t bit_count ) noexcept {
 		if( bit_count >= daw::bsizeof<T> ) {
 			return static_cast<T>( 0 );
 		}
-		return static_cast<T>( ( std::numeric_limits<T>::max )( ) << bit_count );
+		return static_cast<T>( max_value<T> << bit_count );
 	}
 
 	template<typename Bit, typename... Bits>

include/daw/daw_bit_count.h

@@ -0,0 +1,17 @@
+// Copyright (c) Darrell Wright
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/beached/header_libraries
+//
+
+#pragma once
+
+#include <climits>
+#include <cstddef>
+
+namespace daw {
+	template<typename T>
+	inline constexpr std::size_t bit_count_v = sizeof( T ) * CHAR_BIT;
+}

include/daw/daw_bit_queues.h

@@ -8,12 +8,14 @@
 
 #pragma once
 
-#include "ciso646.h"
-#include "daw_bit.h"
-#include "daw_endian.h"
-#include "daw_exception.h"
-#include "daw_move.h"
-#include "traits/daw_traits_conditional.h"
+#include "daw/ciso646.h"
+#include "daw/daw_arith_traits.h"
+#include "daw/daw_bit.h"
+#include "daw/daw_bit_count.h"
+#include "daw/daw_endian.h"
+#include "daw/daw_exception.h"
+#include "daw/daw_move.h"
+#include "daw/traits/daw_traits_conditional.h"
 
 #include <cstdint>
 
@@ -32,14 +34,14 @@ namespace daw {
 		static_assert( std::is_unsigned_v<queue_type> and
 		                 std::is_unsigned_v<value_type>,
 		               "Only unsigned integral types are supported" );
-		size_t m_size = 0;
+		std::size_t m_size = 0;
 		queue_type m_queue = 0;
 
 	public:
 		explicit basic_bit_queue( ) = default;
 
 		constexpr explicit basic_bit_queue( queue_type v ) noexcept
-		  : m_size( sizeof( m_queue ) * 8 )
+		  : m_size( bit_count_v<queue_type> )
 		  , m_queue( std::move( v ) ) {}
 
 		[[nodiscard]] constexpr size_t size( ) const noexcept {
@@ -54,8 +56,8 @@ namespace daw {
 			return 0 == m_size;
 		}
 
-		[[nodiscard]] constexpr size_t capacity( ) const noexcept {
-			return sizeof( m_queue ) * 8;
+		[[nodiscard]] static DAW_CONSTEVAL size_t capacity( ) {
+			return bit_count_v<queue_type>;
 		}
 
 		[[nodiscard]] constexpr bool full( ) const noexcept {
@@ -78,14 +80,14 @@ namespace daw {
 
 	public:
 		constexpr void push_back( value_type value,
-		                          size_t const bits = sizeof( value_type ) * 8 ) {
+		                          size_t const bits = bit_count_v<value_type> ) {
 			daw::exception::dbg_throw_on_false(
 			  ( capacity( ) - m_size ) >= bits,
 			  "Not enough bits to hold value pushed" );
 
 			value &= mask_msb<value_type>(
-			  sizeof( value_type ) * 8 -
-			  bits ); // get_left_mask<value_type>( sizeof( value_type ) * 8 - bits );
+			  bit_count_v<value_type> -
+			  bits ); // get_left_mask<value_type>( bit_count_v<value_type> - bits );
 			m_queue <<= bits;
 			m_queue |= source_to_native_endian( value, BitQueueLSB{ } );
 			m_size += bits;

include/daw/daw_bit_stream.h

@@ -8,60 +8,17 @@
 
 #pragma once
 
-#include "ciso646.h"
-#include "daw_bit_queues.h"
-#include "daw_exception.h"
+#include "daw/ciso646.h"
+#include "daw/daw_bit_count.h"
+#include "daw/daw_bit_queues.h"
+#include "daw/daw_exception.h"
 
 #include <cstdint>
 #include <iterator>
 #include <stdexcept>
 #include <type_traits>
 
 namespace daw {
-	/*template<typename InputIteratorF, typename InputIteratorL> class bit_stream;
-
-	template<typename BitStream>
-	struct bit_stream_iterator: public std::input_iterator_tag {
-	    using value_type = typename
-	std::iterator_traits<InputIteratorF>::value_type; using difference_type =
-	typename std::iterator_traits<InputIteratorF>::difference_type; using
-	reference = typename std::iterator_traits<InputIteratorF>::reference; using
-	pointer = typename std::iterator_traits<InputIteratorF>::pointer; private:
-	    BitStream * m_bit_stream;
-	    bool m_is_end;
-
-	    bool at_end( ) const {
-	        return !m_bit_stream->valid( );
-	    }
-
-	    template<typename InputIteratorF, typename InputIteratorL> friend class
-	bit_stream;
-
-	    bit_stream_iterator( BitStream * bit_stream, bool is_end ):
-	            m_bit_stream{ bit_stream },
-	            m_is_end{ is_end } { }
-	public:
-	    bit_stream_iterator( BitStream & bit_stream ):
-	            bit_stream_iterator{ &bit_stream, !bit_stream } { }
-
-	    bool operator==( bit_stream_iterator const & rhs ) const {
-	        return (std::tie( m_bit_stream, m_bit_stream->m_first,
-	m_bit_stream->m_left_overs ) == std::tie( rhs.m_bit_stream,
-	rhs.m_bit_stream->m_first, rhs.m_bit_stream->m_left_overs )) or (is_end or
-	!valid)
-	    }
-
-	    bool operator!=( bit_stream_iterator const & rhs ) const {
-	        return std::tie( m_bit_stream, m_bit_stream->m_first,
-	m_bit_stream->m_left_overs ) != std::tie( rhs.m_bit_stream,
-	rhs.m_bit_stream->m_first, rhs.m_bit_stream->m_left_overs );
-	    }
-
-	    value_type operator*( ) {
-	        return m_bit
-	    }
-	};*/
-
 	template<typename InputIteratorF, typename InputIteratorL,
 	         typename BitQueueLSB = bit_queue_source_native_endian>
 	struct bit_stream {
@@ -90,9 +47,9 @@ namespace daw {
 			return valid( );
 		}
 
-		value_type pop_bits( size_t num_bits = sizeof( value_type ) * 8 ) {
+		value_type pop_bits( std::size_t num_bits = bit_count_v<value_type> ) {
 			daw::exception::dbg_throw_on_true<std::overflow_error>(
-			  num_bits > sizeof( value_type ) * 8,
+			  num_bits > bit_count_v<value_type>,
 			  "Attempt to pop more bits than can fit into value" );
 			daw::exception::dbg_throw_on_true<std::runtime_error>(
 			  num_bits == 0, "Attempt to pop 0 bits" );
@@ -123,15 +80,15 @@ namespace daw {
 	template<typename T, typename BitStream>
 	auto pop_value( BitStream &bs, size_t bits_needed ) {
 		daw::exception::dbg_throw_on_false(
-		  bits_needed <= sizeof( T ) * 8,
+		  bits_needed <= bit_count_t<T>,
 		  "Attempt to extra more bits than can fit" );
 
 		using value_type = typename BitStream::value_type;
 		T result = 0;
-		while( bits_needed >= sizeof( value_type ) * 8 ) {
-			result <<= sizeof( value_type ) * 8;
+		while( bits_needed >= bit_count_v<value_type> ) {
+			result <<= bit_count_v<value_type>;
 			result |= bs.pop_bits( );
-			bits_needed -= sizeof( value_type ) * 8;
+			bits_needed -= bit_count_v<value_type>;
 		}
 		if( bits_needed > 0 ) {
 			result <<= bits_needed;
@@ -142,28 +99,28 @@ namespace daw {
 
 	template<typename T, typename BitStream>
 	auto pop_value( BitStream &bs ) {
-		return pop_value<T>( bs, sizeof( T ) * 8 );
+		return pop_value<T>( bs, bit_count_v<T> );
 	}
 
 	template<typename BitStream>
 	void skip_bits( BitStream &bs, size_t bits_needed ) {
 		using value_type = typename BitStream::value_type;
 
-		while( bits_needed >= sizeof( value_type ) * 8 ) {
+		while( bits_needed >= bit_count_v<value_type> ) {
 			bs.pop_bits( );
-			bits_needed -= sizeof( value_type ) * 8;
+			bits_needed -= bit_count_v<value_type>;
 		}
 	}
 
 	template<typename BitStream>
 	void skip_bytes( BitStream &bs, size_t bytes_needed ) {
-		skip_bits( bs, bytes_needed * 8 );
+		skip_bits( bs, bytes_needed * bit_count_v<char> );
 	}
 
 	template<typename BitStream, typename TestValue>
 	void skip_until( BitStream &bs, TestValue const &v, size_t bit_count ) {
 		daw::exception::dbg_throw_on_true(
-		  bit_count > sizeof( TestValue ) * 8,
+		  bit_count > bit_count_v<TestValue>,
 		  "Attempt to use more bits than can be put into TestValue" );
 		daw::exception::dbg_throw_on_true( bit_count < 1,
 		                                   "Attempt to pop less than 1 bits" );

include/daw/daw_bitset.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "daw/daw_attributes.h"
+#include "daw/daw_bit_count.h"
 #include "daw/daw_consteval.h"
 
 #include <cassert>
@@ -20,7 +21,7 @@ namespace daw {
 	class bitset {
 		static_assert( BitCount > 2, "BitCount must be greater than 2" );
 		using limb_t = std::uint32_t;
-		static constexpr std::size_t limb_size = sizeof( limb_t ) * 8;
+		static constexpr std::size_t limb_size = bit_count_v<limb_t>;
 		static constexpr std::size_t num_limbs = ( BitCount - 1 ) / limb_size + 1;
 		limb_t m_bits[num_limbs]{ };