Refactored const correctness in pipelines

include/daw/daw_bitset_helper.h

@@ -0,0 +1,68 @@
+// 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 "daw/daw_cpp_feature_check.h"
+#include "daw/daw_ensure.h"
+#include "daw/traits/daw_traits_integer_type.h"
+
+#include <bitset>
+#include <ranges>
+
+namespace daw {
+	namespace create_bs_impl {
+		template<std::size_t N>
+		DAW_CPP23_CX_BITSET_FN auto
+		create_bitset_from_set_positions( auto const &r ) {
+			auto result = std::bitset<N>{ };
+			for( auto const &position : r ) {
+#ifndef NDEBUG
+				using value_t = daw::traits::integral_type_t<
+				  std::ranges::range_value_t<decltype( r )>>;
+				daw_ensure( ( std::is_unsigned_v<value_t> or
+				              static_cast<value_t>( position ) >= 0 ) );
+				daw_ensure( static_cast<std::size_t>( position ) < N );
+#endif
+				result.set( static_cast<std::size_t>( position ) );
+			}
+			return result;
+		}
+	} // namespace create_bs_impl
+
+	template<std::size_t N, typename R>
+	requires( std::ranges::range<R>
+	            and daw::traits::IntegerEnum<std::ranges::range_value_t<R>> ) //
+	  DAW_ATTRIB_FLATTEN DAW_CPP23_CX_BITSET_FN
+	  auto create_bitset_from_set_positions( R const &r ) {
+		return create_bs_impl::create_bitset_from_set_positions<N>( r );
+	}
+
+	template<std::size_t N, daw::traits::IntegerEnum T>
+	DAW_ATTRIB_FLATTEN DAW_CPP23_CX_BITSET_FN auto
+	create_bitset_from_set_positions( std::initializer_list<T> r ) {
+		return create_bs_impl::create_bitset_from_set_positions<N>( r );
+	}
+
+	template<std::size_t N>
+	DAW_ATTRIB_FLATTEN DAW_CPP23_CX_BITSET_FN auto
+	create_bitset_from_set_positions( traits::IntegerEnum auto... positions ) {
+		auto result = std::bitset<N>{ };
+		( result.set( [&]( auto position ) {
+#ifndef NDEBUG
+			using value_t = daw::traits::integral_type_t<decltype( position )>;
+			daw_ensure( ( std::is_unsigned_v<value_t> or
+			              static_cast<value_t>( position ) >= 0 ) );
+			daw_ensure( static_cast<std::size_t>( position ) < N );
+#endif
+			return static_cast<std::size_t>( position );
+		}( positions ) ),
+		  ... );
+		return result;
+	}
+} // namespace daw

include/daw/daw_concepts.h

@@ -26,13 +26,12 @@ namespace daw {
 	/***
 	 * @brief Given types From and To and an expression E whose type and value
 	 * category are the same as those of std::declval<From>(),
-	 * convertible_to<From, To> requires E to be both implicitly and explicitly
-	 * convertible to type To. The implicit and explicit conversions are required
-	 * to produce equal results.
+	 * explicitly_convertible_to<From, To> requires E to be explicitly
+	 * convertible to type To.
 	 */
 	template<typename From, typename To>
-	concept convertible_to = std::is_convertible_v<From, To> and requires {
-		{ static_cast<To>( std::declval<From>( ) ) };
+	concept explicitly_convertible_to = requires {
+		static_cast<To>( std::declval<From>( ) );
 	};
 
 	/***
@@ -44,6 +43,17 @@ namespace daw {
 	template<typename From, typename To>
 	concept implicitly_convertible_to = std::is_convertible_v<From, To>;
 
+	/***
+	 * @brief Given types From and To and an expression E whose type and value
+	 * category are the same as those of std::declval<From>(),
+	 * convertible_to<From, To> requires E to be both implicitly and explicitly
+	 * convertible to type To. The implicit and explicit conversions are required
+	 * to produce equal results.
+	 */
+	template<typename From, typename To>
+	concept convertible_to =
+	  implicitly_convertible_to<From, To> and explicitly_convertible_to<From, To>;
+
 	/***
 	 * @brief Satisfied when Lhs and Rhs name the same type (taking into account
 	 * const/volatile qualifications)
@@ -113,14 +123,14 @@ namespace daw {
 
 	template<typename T>
 	concept ContiguousContainer = requires( T && container ) {
-		{ std::data( container ) } -> Pointers;
-		{ std::size( container ) } -> convertible_to<std::size_t>;
+		{ std::data( container ) }->Pointers;
+		{ std::size( container ) }->convertible_to<std::size_t>;
 	};
 
 	template<typename T, typename U>
 	concept ContiguousContainerOf =
 	  ContiguousContainer<T> and requires( T container ) {
-		{ *std::data( container ) } -> convertible_to<U>;
+		{ *std::data( container ) }->convertible_to<U>;
 	};
 
 	template<typename T>
@@ -182,7 +192,7 @@ namespace daw {
 	  std::assignable_from<LHS, RHS>;
 #else
 	  std::is_lvalue_reference_v<LHS> and requires( LHS lhs, RHS &&rhs ) {
-		{ lhs = DAW_FWD( rhs ) } -> std::same_as<LHS>;
+		{ lhs = DAW_FWD( rhs ) }->std::same_as<LHS>;
 	};
 #endif
 
@@ -238,7 +248,7 @@ namespace daw {
 	  movable<I> and requires( I i ) {
 		typename iter_difference_t<I>;
 		requires SignedStd<iter_difference_t<I>>;
-		{ ++i } -> same_as<I &>;
+		{ ++i }->same_as<I &>;
 		i++;
 	};
 #endif
@@ -253,9 +263,7 @@ namespace daw {
 	 */
 	template<typename Func, typename Result, typename... Args>
 	concept invocable_result = requires( Func && f, Args &&...args ) {
-		{
-			std::invoke( DAW_FWD( f ), DAW_FWD( args )... )
-		} -> convertible_to<Result>;
+		{ std::invoke( DAW_FWD( f ), DAW_FWD( args )... ) }->convertible_to<Result>;
 	};
 
 	template<typename I>
@@ -358,18 +366,18 @@ namespace daw {
 	template<typename B>
 	concept boolean_testable =
 	  concept_details::boolean_testable_impl<B> and requires( B && b ) {
-		{ not DAW_FWD( b ) } -> concept_details::boolean_testable_impl;
+		{ not DAW_FWD( b ) }->concept_details::boolean_testable_impl;
 	};
 
 	namespace concept_details {
 		template<typename T, typename U>
 		concept weakly_equality_comparable_with =
 		  requires( std::remove_reference_t<T> const &t,
 		            std::remove_reference_t<U> const &u ) {
-			{ t == u } -> boolean_testable;
-			{ t != u } -> boolean_testable;
-			{ u == t } -> boolean_testable;
-			{ u != t } -> boolean_testable;
+			{ t == u }->boolean_testable;
+			{ t != u }->boolean_testable;
+			{ u == t }->boolean_testable;
+			{ u != t }->boolean_testable;
 		};
 	} // namespace concept_details
 #endif
@@ -439,7 +447,7 @@ namespace daw {
 
 	template<typename R, typename Fn, typename... Args>
 	concept Callable_r = requires( Fn fn, Args... args ) {
-		{ fn( args... ) } -> convertible_to<R>;
+		{ fn( args... ) }->convertible_to<R>;
 	};
 
 	template<typename Fn, typename... Args>
@@ -457,4 +465,4 @@ namespace daw {
 		{ fn( args... ) } noexcept;
 	};
 } // namespace daw
-#endif
+#endif

include/daw/daw_contiguous_view.h

@@ -8,12 +8,13 @@
 
 #pragma once
 
-#include "daw_concepts.h"
-#include "daw_consteval.h"
-#include "daw_data_end.h"
-#include "daw_utility.h"
-#include "impl/daw_view_tags.h"
-#include "wrap_iter.h"
+#include "daw/daw_concepts.h"
+#include "daw/daw_consteval.h"
+#include "daw/daw_data_end.h"
+#include "daw/daw_ensure.h"
+#include "daw/daw_utility.h"
+#include "daw/impl/daw_view_tags.h"
+#include "daw/wrap_iter.h"
 
 #include <algorithm>
 #include <cassert>
@@ -27,7 +28,8 @@ namespace daw {
 	struct contiguous_view;
 
 	template<typename T, bool ExplicitConv>
-	requires( not std::is_const_v<T> ) struct contiguous_view<T, ExplicitConv> {
+	requires( not std::is_const_v<T> ) //
+	  struct contiguous_view<T, ExplicitConv> {
 		using value_type = T;
 		using reference = value_type &;
 		using const_reference = value_type const &;
@@ -45,7 +47,8 @@ namespace daw {
 		pointer m_last = nullptr;
 
 	public:
-		contiguous_view( ) = default;
+		explicit contiguous_view( ) = default;
+
 		constexpr contiguous_view( contiguous_view &other ) noexcept
 		  : m_first( other.m_first )
 		  , m_last( other.m_last ) {}
@@ -70,6 +73,15 @@ namespace daw {
 		  : m_first( std::data( c ) )
 		  , m_last( daw::data_end( c ) ) {}
 
+		template<ContiguousContainerOf<value_type> Container>
+		requires( not_cvref_of<contiguous_view, Container> ) explicit(
+		  ExplicitConv ) constexpr contiguous_view( Container &&c,
+		                                            std::size_t count ) noexcept
+		  : m_first( std::data( c ) )
+		  , m_last( std::next( m_first, static_cast<difference_type>( count ) ) ) {
+			daw_ensure( count <= std::size( c ) );
+		}
+
 		template<constructible_from<pointer, size_type> Container>
 		explicit constexpr operator Container( ) const noexcept {
 			return Container{ data( ), size( ) };
@@ -226,7 +238,7 @@ namespace daw {
 		}
 
 		constexpr void remove_prefix( std::size_t count ) noexcept {
-			count = ( std::min )( count, size( ) );
+			count = (std::min)( count, size( ) );
 			m_first += count;
 		}
 
@@ -241,7 +253,7 @@ namespace daw {
 		}
 
 		constexpr void remove_suffix( std::size_t count ) noexcept {
-			count = ( std::min )( count, size( ) );
+			count = (std::min)( count, size( ) );
 			m_last -= count;
 		}
 
@@ -397,8 +409,8 @@ namespace daw {
 
 		[[nodiscard]] friend constexpr bool operator<( contiguous_view const &x,
 		                                               contiguous_view const &y ) {
-			return std::lexicographical_compare( x.data( ), x.data_end( ), y.data( ),
-			                                     y.data_end( ) );
+			return std::lexicographical_compare(
+			  x.data( ), x.data_end( ), y.data( ), y.data_end( ) );
 		}
 
 		[[nodiscard]] friend constexpr bool operator>( contiguous_view const &x,
@@ -418,8 +430,8 @@ namespace daw {
 	};
 
 	template<typename T, bool ExplicitConv>
-	requires( std::is_const_v<T> ) struct contiguous_view<T, ExplicitConv> {
-
+	requires( std::is_const_v<T> ) //
+	  struct contiguous_view<T, ExplicitConv> {
 		using value_type = T;
 		using reference = value_type &;
 		using const_reference = value_type const &;
@@ -458,6 +470,15 @@ namespace daw {
 		  : m_first( std::data( c ) )
 		  , m_last( daw::data_end( c ) ) {}
 
+		template<ContiguousContainerOf<value_type> Container>
+		requires( not_cvref_of<contiguous_view, Container> ) explicit(
+		  ExplicitConv ) constexpr contiguous_view( Container &&c,
+		                                            std::size_t count ) noexcept
+		  : m_first( std::data( c ) )
+		  , m_last( std::next( m_first, static_cast<difference_type>( count ) ) ) {
+			daw_ensure( count <= std::size( c ) );
+		}
+
 		template<constructible_from<pointer, size_type> Container>
 		explicit constexpr operator Container( ) const noexcept {
 			return Container{ data( ), size( ) };
@@ -593,7 +614,7 @@ namespace daw {
 		}
 
 		constexpr void remove_prefix( std::size_t count ) noexcept {
-			count = ( std::min )( count, size( ) );
+			count = (std::min)( count, size( ) );
 			m_first += count;
 		}
 
@@ -608,7 +629,7 @@ namespace daw {
 		}
 
 		constexpr void remove_suffix( std::size_t count ) noexcept {
-			count = ( std::min )( count, size( ) );
+			count = (std::min)( count, size( ) );
 			m_last -= count;
 		}
 
@@ -764,8 +785,8 @@ namespace daw {
 
 		[[nodiscard]] friend constexpr bool operator<( contiguous_view const &x,
 		                                               contiguous_view const &y ) {
-			return std::lexicographical_compare( x.data( ), x.data_end( ), y.data( ),
-			                                     y.data_end( ) );
+			return std::lexicographical_compare(
+			  x.data( ), x.data_end( ), y.data( ), y.data_end( ) );
 		}
 
 		[[nodiscard]] friend constexpr bool operator>( contiguous_view const &x,
@@ -784,18 +805,26 @@ namespace daw {
 		}
 	};
 
-	template<typename T>
-	contiguous_view( T *, T * ) -> contiguous_view<T>;
+	template<Pointers P>
+	contiguous_view( P, P ) -> contiguous_view<std::remove_pointer_t<P>>;
 
-	template<typename T>
-	contiguous_view( T *, std::size_t ) -> contiguous_view<T>;
+	template<Pointers P, IntegralStd SizeT>
+	contiguous_view( P, SizeT ) -> contiguous_view<std::remove_pointer_t<P>>;
 
 	template<ContiguousContainer Container>
-	contiguous_view( Container &&c )
-	  -> contiguous_view<std::remove_reference_t<decltype( *std::data( c ) )>>;
+	contiguous_view( Container &&c ) -> contiguous_view<std::conditional_t<
+	  std::is_const_v<std::remove_reference_t<Container>>,
+	  daw::range_value_t<Container> const, daw::range_value_t<Container>>>;
+
+	template<ContiguousContainer Container, IntegralStd SizeT>
+	contiguous_view( Container &&c, SizeT ) -> contiguous_view<std::conditional_t<
+	  std::is_const_v<std::remove_reference_t<Container>>,
+	  daw::range_value_t<Container> const, daw::range_value_t<Container>>>;
 
 	template<typename T, std::size_t N>
 	contiguous_view( T ( & )[N] ) -> contiguous_view<T>;
 
+	template<typename T, std::size_t N>
+	contiguous_view( T ( & )[N], std::size_t ) -> contiguous_view<T>;
 } // namespace daw
 DAW_UNSAFE_BUFFER_FUNC_STOP

include/daw/daw_cpp_feature_check.h

@@ -227,4 +227,22 @@ inline constexpr bool daw_has_cx_cmath = false;
 #if __cpp_lib_move_only_function >= 202110L
 #define DAW_HAS_CPP23_MOVE_ONLY_FUNCTION
 #endif
+#endif
+
+#if defined( __cpp_lib_constexpr_bitset )
+#if __cpp_lib_constexpr_bitset >= 202202L
+#define DAW_HAS_CPP23_CONSTEXPR_BITSET 1
+#endif
+#endif
+
+#if defined( DAW_HAS_CPP23_CONSTEXPR_BITSET )
+#define DAW_CPP23_CX_BITSET_FN constexpr
+#define DAW_CPP23_CX_BITSET constexpr
+#else
+#define DAW_CPP23_CX_BITSET_FN inline
+#define DAW_CPP23_CX_BITSET
+#endif
+
+#if __cpp_lib_optional >= 202506L
+#define DAW_HAS_CPP26_OPTIONAL_REFS
 #endif