Modules

Description

Classes
struct	eswitch_v5::regexter

Functions
static auto	eswitch_v5::operator== (const std::string &tuple_entry, const regexter &value)
	CaseModule to support for matching and withdrawing of values for and from regular expression. More...
template<typename TupleEntry , typename UnderlyingType >
static constexpr auto	eswitch_v5::operator== (TupleEntry &&tuple_entry, const is< UnderlyingType > &) noexcept
	CaseModule to support for matching for various polymorphic types. More...

Function Documentation

operator==() [1/2]

static auto eswitch_v5::operator== ( const std::string &  tuple_entry, const regexter &  value  )

static

#include <eswitch_v5.hpp>

CaseModule to support for matching and withdrawing of values for and from regular expression.

Definition at line 413 of file eswitch_v5.hpp.

    {
        if( std::smatch match; std::regex_match( tuple_entry, match, value.value ) )
        {              
            std::vector< std::string > vs;
            vs.reserve( match.size() );
 
            for( const auto & v : match )  
                vs.push_back( v );
 
            return std::make_optional( std::move( vs ) );
        }
 
        return std::optional< std::vector< std::string > >{};
    }

operator==() [2/2]

template<typename TupleEntry , typename UnderlyingType >

static constexpr auto eswitch_v5::operator== ( TupleEntry &&  tuple_entry, const is< UnderlyingType > &    )

staticconstexprnoexcept

#include <eswitch_v5.hpp>

CaseModule to support for matching for various polymorphic types.

CaseModule to support for matching and withdrawing of values from std::any.

Definition at line 432 of file eswitch_v5.hpp.

    {
        using _T = std::remove_reference_t< TupleEntry >;
 
        using type = std::conditional_t< std::is_const_v< std::remove_pointer_t< _T > >, 
                const UnderlyingType, UnderlyingType >;
 
        if constexpr( std::is_pointer_v< _T > )
        {
            auto * d = dynamic_cast< type* >( tuple_entry );
 
            return d != nullptr ? std::make_optional( d ) : std::optional< type* >{};                
        }
        else
        {
            try
            {
                auto & d = dynamic_cast< type& >( tuple_entry );
                return std::make_optional( std::ref( d ) );
            }
            catch( const std::bad_cast & )
            {                    
                return std::optional< std::reference_wrapper< type > >{};
            }
        }
    }