Main-components

Description

Classes
class	eswitch_v5::condition< CmpOperator, TIndex, CaseEntry >
	Compares value with corresponding entry in std::tuple. More...
struct	eswitch_v5::condition_with_predicate< Cnd, Func >
class	eswitch_v5::conditions< LogicalOperator, Cnds >
	Container which holds arbitrary number of condition. More...
class	eswitch_v5::eswitch_impl< Args >
	Accept arbitrary number of Case's and test each of them sequentially. If match was found then executes Case body, also based on Case falling option decides whether to execute next body or finish work. More...
struct	eswitch_v5::Fallthrough
struct	eswitch_v5::is< T >
	Used to match for type of active entry in std::any, std::variant<...> and polymorphic types. More...
class	eswitch_v5::predicate_condition< TPred, Is >

Enumerations
enum	eswitch_v5::Comparison_operators {   eswitch_v5::Comparison_operators::equal, eswitch_v5::Comparison_operators::not_equal, eswitch_v5::Comparison_operators::greater, eswitch_v5::Comparison_operators::greater_or_equal,   eswitch_v5::Comparison_operators::less, eswitch_v5::Comparison_operators::less_or_equal }
enum	eswitch_v5::Logical_operators { eswitch_v5::Logical_operators::and_, eswitch_v5::Logical_operators::or_ }

Functions
template<typename ... Args>
static constexpr auto	eswitch_v5::any_from (Args &&... args)
	Helper function which allows to find if something is within the list( passed arguments ). More...
template<Condition Cnd>
static constexpr auto	eswitch_v5::case_ (Cnd &&cnd)
template<typename ... Ts>
static constexpr auto	eswitch_v5::case_ (Ts &&... values)
template<typename P , std::size_t ... I, Index Idx>
predicate_condition< P, I..., Idx::eswitch_index >	eswitch_v5::compose_new_predicate_condition_type (const predicate_condition< P, I... > &, Idx)
template<StdPair T>
static constexpr auto	eswitch_v5::eswitch (T &&pair)
	This overload expand std::pair. Simplifies following form eswitch( pair.first, pair.second ) to eswitch( pair ). Moreover there is similar overload for std::tuple. More...
template<typename ... Ts>
static constexpr auto	eswitch_v5::eswitch (Ts &&... ts)
	This function is responsible for passing arguments for class eswitch_impl with overloaded operator(), which accepts arbitrary number of Case's. More...
template<Index Idx, typename T >
constexpr auto	eswitch_v5::operator!= (Idx &&, T &&rhv)
auto	eswitch_v5::operator""_r (const char *rgx, const std::size_t sz)
	User-defined literals for std::regex. More...
template<Condition T, Callable Func>
static constexpr auto	eswitch_v5::operator% (T &&cnd, Func &&f)
template<Condition Cnd1, Condition Cnd2>
static constexpr auto	eswitch_v5::operator&& (Cnd1 &&cnd1, Cnd2 &&cnd2)
template<Condition ... Cnds, Condition Cnd>
static constexpr auto	eswitch_v5::operator&& (conditions< Logical_operators::and_, Cnds... > &&cnds, Cnd &&cnd)
template<IsNotCndPredicate Pred, Index Idx>
static constexpr auto	eswitch_v5::operator, (Pred &&pred, Idx)
template<typename R , typename... Args, Index Idx>
static constexpr auto	eswitch_v5::operator, (R(*pred)(Args...), Idx)
template<Index Idx, typename T >
constexpr auto	eswitch_v5::operator< (Idx &&, T &&rhv)
template<Index Idx, typename T >
constexpr auto	eswitch_v5::operator<= (Idx &&, T &&rhv)
template<Index Idx, typename T >
static constexpr auto	eswitch_v5::operator== (Idx &&, T &&rhv)
template<Index Idx, typename T >
constexpr auto	eswitch_v5::operator> (Idx &&, T &&rhv)
template<Index Idx, typename T >
constexpr auto	eswitch_v5::operator>= (Idx &&, T &&rhv)
template<typename Cnd , ReturnValueNoneVoid Func>
static constexpr auto	eswitch_v5::operator^ (condition_with_predicate< Cnd, Func > &&cp, const Fallthrough &)
template<Condition Cnd1, Condition Cnd2>
static constexpr auto	eswitch_v5::operator|| (Cnd1 &&cnd1, Cnd2 &&cnd2)
template<Condition ... Cnds, Condition Cnd>
static constexpr auto	eswitch_v5::operator|| (conditions< Logical_operators::or_, Cnds... > &&cnds, Cnd &&cnd)

Enumeration Type Documentation

Comparison_operators

enum eswitch_v5::Comparison_operators

strong

#include <eswitch_v5.hpp>

Enumerator
equal
not_equal
greater
greater_or_equal
less
less_or_equal

Definition at line 50 of file eswitch_v5.hpp.

{ equal, not_equal, greater, greater_or_equal, less, less_or_equal };

Logical_operators

enum eswitch_v5::Logical_operators

strong

#include <eswitch_v5.hpp>

Enumerator
and_
or_

Definition at line 49 of file eswitch_v5.hpp.

{ and_, or_ };

Function Documentation

any_from()

template<typename ... Args>

static constexpr auto eswitch_v5::any_from ( Args &&...  args )

staticconstexpr

#include <eswitch_v5.hpp>

Helper function which allows to find if something is within the list( passed arguments ).

Definition at line 991 of file eswitch_v5.hpp.

    {
        return extension::Any_from_impl( std::forward< Args >( args )... );
    }

case_() [1/2]

template<Condition Cnd>

static constexpr auto eswitch_v5::case_ ( Cnd &&  cnd )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 968 of file eswitch_v5.hpp.

    { 
        return std::move( cnd ); 
    }

case_() [2/2]

template<typename ... Ts>

static constexpr auto eswitch_v5::case_ ( Ts &&...  values )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 974 of file eswitch_v5.hpp.

    {
        auto lmbd = []< typename T, T ... ints >( std::index_sequence< ints... >&&, auto &&... values )
        {
            // I intentionally avoided std::make_tuple, because the former change type of string literals
            // from "const char[some_size]&" to "const char*" and this significantly impacts the performance.
            return details::create_indexed_condition< ints... >( 
                std::tuple< Ts... >( std::forward< Ts >( values )... ) ); 
        };
 
        return lmbd( std::make_index_sequence< sizeof...(Ts) >{},
            std::forward< Ts >( values )... );
    }

compose_new_predicate_condition_type()

template<typename P , std::size_t ... I, Index Idx>

predicate_condition< P, I..., Idx::eswitch_index > eswitch_v5::compose_new_predicate_condition_type	(	const predicate_condition< P, I... > &	,
		Idx
	)

#include <eswitch_v5.hpp>

eswitch() [1/2]

template<StdPair T>

static constexpr auto eswitch_v5::eswitch ( T &&  pair )

staticconstexpr

#include <eswitch_v5.hpp>

This overload expand std::pair. Simplifies following form eswitch( pair.first, pair.second ) to eswitch( pair ). Moreover there is similar overload for std::tuple.

Definition at line 848 of file eswitch_v5.hpp.

    {
        if constexpr( std::is_rvalue_reference_v< T&& > )
        {
            return eswitch_impl( std::move( pair.first ), std::move( pair.second ) );
        }
        else
        {
            return eswitch_impl( pair.first, pair.second );
        }
    }

eswitch() [2/2]

template<typename ... Ts>

static constexpr auto eswitch_v5::eswitch ( Ts &&...  ts )

staticconstexpr

#include <eswitch_v5.hpp>

This function is responsible for passing arguments for class eswitch_impl with overloaded operator(), which accepts arbitrary number of Case's.

Definition at line 838 of file eswitch_v5.hpp.

    {
        return eswitch_impl( std::forward< Ts >( ts )... );
    }

operator!=()

template<Index Idx, typename T >

constexpr auto eswitch_v5::operator!= ( Idx &&  , T &&  rhv  )

constexpr

#include <eswitch_v5.hpp>

Definition at line 670 of file eswitch_v5.hpp.

    {
        return condition< Comparison_operators::not_equal, std::decay_t< Idx >, T >( std::forward< T >( rhv ) );
    }

operator""_r()

auto eswitch_v5::operator""_r	(	const char *	rgx,
		const std::size_t	sz
	)

#include <eswitch_v5.hpp>

User-defined literals for std::regex.

Definition at line 1005 of file eswitch_v5.hpp.

    {
        return regexter{ std::regex{ rgx } };
    }

operator%()

template<Condition T, Callable Func>

static constexpr auto eswitch_v5::operator% ( T &&  cnd, Func &&  f  )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 894 of file eswitch_v5.hpp.

    {
        return condition_with_predicate{ std::move( cnd ), std::move( f ) };
    }

operator&&() [1/2]

template<Condition Cnd1, Condition Cnd2>

static constexpr auto eswitch_v5::operator&& ( Cnd1 &&  cnd1, Cnd2 &&  cnd2  )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 645 of file eswitch_v5.hpp.

    {
        return conditions< Logical_operators::and_, Cnd1, Cnd2 >( std::move( cnd1 ), std::move( cnd2 ) );
    }

operator&&() [2/2]

template<Condition ... Cnds, Condition Cnd>

static constexpr auto eswitch_v5::operator&& ( conditions< Logical_operators::and_, Cnds... > &&  cnds, Cnd &&  cnd  )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 638 of file eswitch_v5.hpp.

    {
        return conditions< Logical_operators::and_, Cnds..., Cnd >( 
            std::move( cnds ), std::move( cnd ) );
    }

operator,() [1/2]

template<IsNotCndPredicate Pred, Index Idx>

static constexpr auto eswitch_v5::operator, ( Pred &&  pred, Idx  idx  )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 947 of file eswitch_v5.hpp.

    {
        return predicate_condition< std::remove_reference_t< Pred >, Idx::eswitch_index >( 
            std::forward< Pred >( pred ) );
    }

operator,() [2/2]

template<typename R , typename... Args, Index Idx>

static constexpr auto eswitch_v5::operator, ( R(*)(Args...)  pred, Idx    )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 941 of file eswitch_v5.hpp.

    {
        return predicate_condition< R(*)(Args...), Idx::eswitch_index >( pred );
    }

operator<()

template<Index Idx, typename T >

constexpr auto eswitch_v5::operator< ( Idx &&  , T &&  rhv  )

constexpr

#include <eswitch_v5.hpp>

Definition at line 688 of file eswitch_v5.hpp.

    {
        return condition< Comparison_operators::less, std::decay_t< Idx >, T >( std::forward< T >( rhv ) );
    }

operator<=()

template<Index Idx, typename T >

constexpr auto eswitch_v5::operator<= ( Idx &&  , T &&  rhv  )

constexpr

#include <eswitch_v5.hpp>

Definition at line 694 of file eswitch_v5.hpp.

    {
        return condition< Comparison_operators::less_or_equal, std::decay_t< Idx >, T >( std::forward< T >( rhv ) );
    }

operator==()

template<Index Idx, typename T >

static constexpr auto eswitch_v5::operator== ( Idx &&  , T &&  rhv  )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 664 of file eswitch_v5.hpp.

    {
        return condition< Comparison_operators::equal, std::decay_t< Idx >, T >( std::forward< T >( rhv ) );
    }

operator>()

template<Index Idx, typename T >

constexpr auto eswitch_v5::operator> ( Idx &&  , T &&  rhv  )

constexpr

#include <eswitch_v5.hpp>

Definition at line 676 of file eswitch_v5.hpp.

    {
        return condition< Comparison_operators::greater, std::decay_t< Idx >, T >( std::forward< T >( rhv ) );
    }

operator>=()

template<Index Idx, typename T >

constexpr auto eswitch_v5::operator>= ( Idx &&  , T &&  rhv  )

constexpr

#include <eswitch_v5.hpp>

Definition at line 682 of file eswitch_v5.hpp.

    {
        return condition< Comparison_operators::greater_or_equal, std::decay_t< Idx >, T >( std::forward< T >( rhv ) );
    }

operator^()

template<typename Cnd , ReturnValueNoneVoid Func>

static constexpr auto eswitch_v5::operator^ ( condition_with_predicate< Cnd, Func > &&  cp, const Fallthrough &    )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 902 of file eswitch_v5.hpp.

    {
        cp.fallthrough = true;
 
        return std::move( cp );
    }

operator||() [1/2]

template<Condition Cnd1, Condition Cnd2>

static constexpr auto eswitch_v5::operator|| ( Cnd1 &&  cnd1, Cnd2 &&  cnd2  )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 658 of file eswitch_v5.hpp.

    {
        return conditions< Logical_operators::or_, Cnd1, Cnd2 >( std::move( cnd1 ), std::move( cnd2 ) );
    }

operator||() [2/2]

template<Condition ... Cnds, Condition Cnd>

static constexpr auto eswitch_v5::operator|| ( conditions< Logical_operators::or_, Cnds... > &&  cnds, Cnd &&  cnd  )

staticconstexpr

#include <eswitch_v5.hpp>

Definition at line 651 of file eswitch_v5.hpp.

    {
        return conditions< Logical_operators::or_, Cnds..., Cnd >( 
            std::move( cnds ), std::move( cnd ) );
    }