adam/Alepha
1
0
Fork 0
forked from Alepha/Alepha
Code Pull Requests Activity

Unify everything to template_for form.

Browse Source
This commit is contained in:
ADAM David Alan Martin
2024-07-05 12:18:18 -04:00
parent 32e6c36570
commit 970cfa3b62
5 changed files with 91 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
IOStreams/IStreamable.h
View File

@ -51,7 +51,7 @@ namespace Alepha::Hydrogen::IOStreams ::detail:: IStreamable_m
int index= 0;
// TODO: Consider the lens system here... but the basic use case seems to be for
// aggregates, so we'll go with this simple case for now...
tuple_for_each( decomposed ) <=[&]( auto &element )
template_for( decomposed ) <=[&]( auto &element )
{
std::istringstream iss{ tokens.at( index++ ) };
iss >> element;

2
IOStreams/OStreamable.h
View File

@ -45,7 +45,7 @@ namespace Alepha::Hydrogen::IOStreams ::detail:: OStreamable_m
// TODO: Consider the lens system here... but the basic use case seems to be for
// aggregates, so we'll go with this simple case for now...
tuple_for_each( decomposed ) <=[&]( const auto &element )
template_for( decomposed ) <=[&]( const auto &element )
{
os << NextItem << element;
};

2
Testing/TableTest.h
View File

@ -206,7 +206,7 @@ namespace Alepha::Hydrogen::Testing ::detail:: TableTest_m
oss << std::endl << "Test inputs were: " << std::endl;
int index= 0;
tuple_for_each( params ) <=[&]( const auto &param )
template_for( params ) <=[&]( const auto &param )
{
// Debugging output for test inputs is relaxed, as it's not required they be streamable?
oss << "Argument " << index++ << ": " << streamAdaptValue< OutputMode::Relaxed >( param ) << std::endl;

2
Testing/printDebugging.h
View File

@ -108,7 +108,7 @@ namespace Alepha::Hydrogen::Testing ::detail:: printDebugging_m
else if constexpr( Meta::is_tuple_v< T > )
{
oss << '[';
tuple_for_each( v ) <=[&oss, first= true]( const auto &elem ) mutable
template_for( v ) <=[&oss, first= true]( const auto &elem ) mutable
{
if( not first ) oss << ", ";
first= false;

79
template_for.h
View File

@ -14,11 +14,38 @@ namespace Alepha::Hydrogen ::detail:: template_for_each_m
{
inline namespace exports
{
constexpr void tuple_for_each( const std::tuple<> &, const Functional auto ) noexcept {}
template< Tuple Type >
[[nodiscard]]
constexpr auto
template_for( Type &tuple ) noexcept;
template< Tuple Type >
[[nodiscard]]
constexpr auto
template_for( const Type &tuple ) noexcept;
template< Aggregate Type >
[[nodiscard]]
constexpr auto
template_for( Type &agg, std::optional< Reflection::aggregate_tuple_t< Type > > &&tupled= {} ) noexcept
{
tupled= Reflection::tuplizeAggregate( agg );
return template_for( *tupled );
}
template< Aggregate Type >
[[nodiscard]]
constexpr auto
template_for( const Type &agg, std::optional< Reflection::aggregate_tuple_t< Type > > &&tupled= {} ) noexcept
{
tupled= Reflection::tuplizeAggregate( agg );
return template_for( *tupled );
}
}
template< typename ... Args, typename Function >
constexpr void
tuple_for_each( const std::tuple< Args... > &tuple, Function body )
template_for_impl( const std::tuple< Args... > &tuple, Function body )
noexcept
(
( ... and noexcept( body( std::declval< const Args & >() ) ) )
@ -36,31 +63,18 @@ namespace Alepha::Hydrogen ::detail:: template_for_each_m
std::apply( loop_body_handler, tuple );
}
// Apply type_identity to all tuple elements
template< typename > struct type_identify_tuple;
template< typename T >
using type_identify_tuple_t= typename type_identify_tuple< T >::type;
template<> struct type_identify_tuple< std::tuple<> > { using type= std::tuple<>; };
template< typename ... Args >
struct type_identify_tuple< std::tuple< Args... > >
{
using type= std::tuple< std::type_identity< Args >... >;
};
// Nicer for-each syntax helper:
template< typename Tuple >
struct for_each_syntax_adaptor
struct [[nodiscard]] syntax_adaptor
{
Tuple &tuple;
template< typename Function >
constexpr void
operator <= ( Function &&func ) noexcept( noexcept( tuple_for_each( tuple, std::forward< Function >( func ) ) ) )
operator <= ( Function &&func ) noexcept( noexcept( template_for_impl( tuple, std::forward< Function >( func ) ) ) )
{
return tuple_for_each( tuple, std::forward< Function >( func ) );
return template_for_impl( tuple, std::forward< Function >( func ) );
}
constexpr operator decltype( std::ignore ) () const= delete;
@ -69,43 +83,34 @@ namespace Alepha::Hydrogen ::detail:: template_for_each_m
template< typename Tuple >
[[nodiscard]]
constexpr auto
tuple_for_each( Tuple &tuple ) noexcept
template_for_impl( Tuple &tuple ) noexcept
{
return for_each_syntax_adaptor< Tuple >{ tuple };
return syntax_adaptor< Tuple >{ tuple };
}
template< typename Tuple >
[[nodiscard]]
constexpr auto
tuple_for_each( const Tuple &tuple ) noexcept
template_for_impl( const Tuple &tuple ) noexcept
{
return for_each_syntax_adaptor< const Tuple >{ tuple };
return syntax_adaptor< const Tuple >{ tuple };
}
template< typename Type >
concept TemplateLoopable= false
or Tuple< Type >
or Aggregate< Type >
// or Array< T > // Do we need array support? Does it matter?
;
template< TemplateLoopable Type >
template< Tuple Type >
[[nodiscard]]
constexpr auto
template_for( Type &tuple, std::optional< Reflection::aggregate_tuple_t< Type > > &&tupled= {} ) noexcept
exports::template_for( Type &tuple ) noexcept
{
tupled= Reflection::tuplizeAggregate( tuple );
return tuple_for_each( *tupled );
return template_for_impl( tuple );
}
template< TemplateLoopable Type >
template< Tuple Type >
[[nodiscard]]
constexpr auto
template_for( const Type &tuple, std::optional< Reflection::aggregate_tuple_t< Type > > &&tupled= {} ) noexcept
exports::template_for( const Type &tuple ) noexcept
{
tupled= Reflection::tuplizeAggregate( tuple );
return tuple_for_each( *tupled );
}
return template_for_impl( tuple );
}
}