decompose.h File Reference

#include "../concepts.h"
#include <tuple>

Include dependency graph for decompose.h:

Go to the source code of this file.

Classes
struct	emlabcpp::detail::decompose_anything< size_t >

Namespaces
	emlabcpp
	MIT License.
	emlabcpp::detail

Macros
#define	EMLABCPP_GENERATE_DECOMPOSE(ID, ...)

Functions
template<class T , std::size_t I0, std::size_t... I>
constexpr auto	emlabcpp::detail::decompose_count_impl (int &out, std::index_sequence< I0, I... >) -> std::add_pointer_t< decltype(T{ decompose_anything< I0 >{}, decompose_anything< I >{}... }) >
template<class T , std::size_t... I>
constexpr void *	emlabcpp::detail::decompose_count_impl (int &out, std::index_sequence< I... >)
template<typename T >
constexpr int	emlabcpp::detail::decompose_count ()
template<decomposable_0 T>
constexpr std::tuple	emlabcpp::decompose (T &&)
template<typename T , typename Tuple >
constexpr T	emlabcpp::compose (Tuple tpl)
	emlabcpp::EMLABCPP_GENERATE_DECOMPOSE (16, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) template< typename T > using decomposed_type

Variables
static constexpr std::size_t	emlabcpp::detail::max_decompose_count = 16
template<typename T >
concept	emlabcpp::decomposable
template<typename T >
concept	emlabcpp::decomposable_0 = decomposable< T > && ( detail::decompose_count< T >() == 0 )

Macro Definition Documentation

EMLABCPP_GENERATE_DECOMPOSE

#define EMLABCPP_GENERATE_DECOMPOSE	(		ID,
			...
	)

Value:

        template < typename T >                                                                    \
        concept decomposable_##ID = decomposable< T > && detail::decompose_count< T >() == ( ID ); \
                                                                                                   \
        template < decomposable_##ID T >                                                           \
        constexpr auto decompose( T&& item )                                                       \
        {                                                                                          \
                if constexpr ( !std::is_lvalue_reference_v< T > ) {                                \
                        auto&& [__VA_ARGS__] = std::forward< T >( item );                          \
                        return std::make_tuple( __VA_ARGS__ );                                     \
                } else {                                                                           \
                        auto& [__VA_ARGS__] = item;                                                \
                        return std::tie( __VA_ARGS__ );                                            \
                }                                                                                  \
        }