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

169
template_for.h
View File

@ -14,98 +14,103 @@ 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< typename ... Args, typename Function >
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
template_for_impl( const std::tuple< Args... > &tuple, Function body )
noexcept
(
( ... and noexcept( body( std::declval< const Args & >() ) ) )
)
{
const auto callWrapper= [&body]( auto &&element ) { body( element ); return nullptr; };
auto loop_body_handler= [&]( auto &&... tuple_elements )
{
std::nullptr_t expansion[]= { callWrapper( tuple_elements )... };
std::ignore= expansion;
};
std::apply( loop_body_handler, tuple );
}
// Nicer for-each syntax helper:
template< typename Tuple >
struct [[nodiscard]] syntax_adaptor
{
Tuple &tuple;
template< typename Function >
constexpr void
tuple_for_each( const std::tuple< Args... > &tuple, Function body )
noexcept
(
( ... and noexcept( body( std::declval< const Args & >() ) ) )
)
operator <= ( Function &&func ) noexcept( noexcept( template_for_impl( tuple, std::forward< Function >( func ) ) ) )
{
const auto callWrapper= [&body]( auto &&element ) { body( element ); return nullptr; };
auto loop_body_handler= [&]( auto &&... tuple_elements )
{
std::nullptr_t expansion[]= { callWrapper( tuple_elements )... };
std::ignore= expansion;
};
std::apply( loop_body_handler, tuple );
return template_for_impl( tuple, std::forward< Function >( func ) );
}
// Apply type_identity to all tuple elements
template< typename > struct type_identify_tuple;
constexpr operator decltype( std::ignore ) () const= delete;
};
template< typename T >
using type_identify_tuple_t= typename type_identify_tuple< T >::type;
template< typename Tuple >
[[nodiscard]]
constexpr auto
template_for_impl( Tuple &tuple ) noexcept
{
return syntax_adaptor< Tuple >{ tuple };
}
template<> struct type_identify_tuple< std::tuple<> > { using type= std::tuple<>; };
template< typename Tuple >
[[nodiscard]]
constexpr auto
template_for_impl( const Tuple &tuple ) noexcept
{
return syntax_adaptor< const Tuple >{ 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
{
Tuple &tuple;
template< Tuple Type >
[[nodiscard]]
constexpr auto
exports::template_for( Type &tuple ) noexcept
{
return template_for_impl( tuple );
}
template< typename Function >
constexpr void
operator <= ( Function &&func ) noexcept( noexcept( tuple_for_each( tuple, std::forward< Function >( func ) ) ) )
{
return tuple_for_each( tuple, std::forward< Function >( func ) );
}
constexpr operator decltype( std::ignore ) () const= delete;
};
template< typename Tuple >
[[nodiscard]]
constexpr auto
tuple_for_each( Tuple &tuple ) noexcept
{
return for_each_syntax_adaptor< Tuple >{ tuple };
}
template< typename Tuple >
[[nodiscard]]
constexpr auto
tuple_for_each( const Tuple &tuple ) noexcept
{
return for_each_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 >
[[nodiscard]]
constexpr auto
template_for( Type &tuple, std::optional< Reflection::aggregate_tuple_t< Type > > &&tupled= {} ) noexcept
{
tupled= Reflection::tuplizeAggregate( tuple );
return tuple_for_each( *tupled );
}
template< TemplateLoopable Type >
[[nodiscard]]
constexpr auto
template_for( const Type &tuple, std::optional< Reflection::aggregate_tuple_t< Type > > &&tupled= {} ) noexcept
{
tupled= Reflection::tuplizeAggregate( tuple );
return tuple_for_each( *tupled );
}
template< Tuple Type >
[[nodiscard]]
constexpr auto
exports::template_for( const Type &tuple ) noexcept
{
return template_for_impl( tuple );
}
}