clara::detail Namespace Reference

Classes
class	Arg
class	Args
class	BasicResult
struct	BoundFlagLambda
struct	BoundFlagRef
struct	BoundFlagRefBase
struct	BoundLambda
struct	BoundRef
struct	BoundValueRef
struct	BoundValueRef< std::vector< T > >
struct	BoundValueRefBase
class	ComposableParserImpl
class	ExeName
struct	Help
struct	HelpColumns
struct	LambdaInvoker
struct	LambdaInvoker< void >
struct	NonCopyable
class	Opt
struct	Parser
class	ParserBase
class	ParserRefImpl
class	ParseState
class	ResultBase
class	ResultValueBase
class	ResultValueBase< void >
struct	Token
class	TokenStream
struct	UnaryLambdaTraits
struct	UnaryLambdaTraits< ReturnT(ClassT::*)(Args...) const >
struct	UnaryLambdaTraits< ReturnT(ClassT::*)(ArgT) const >

Typedefs
using	Result = BasicResult<void>
using	ParserResult = BasicResult<ParseResultType>
using	InternalParseResult = BasicResult<ParseState>

Enumerations
enum class	TokenType { Option , Argument }
enum class	ParseResultType { Matched , NoMatch , ShortCircuitAll , ShortCircuitSame }
enum class	Optionality { Optional , Required }

Functions
auto	isOptPrefix (char c) -> bool
template<typename T >
auto	convertInto (std::string const &source, T &target) -> ParserResult
auto	convertInto (std::string const &source, std::string &target) -> ParserResult
auto	convertInto (std::string const &source, bool &target) -> ParserResult
template<typename ArgType , typename L >
auto	invokeLambda (L const &lambda, std::string const &arg) -> ParserResult
auto	normaliseOpt (std::string const &optName) -> std::string

Typedef Documentation

InternalParseResult

using clara::detail::InternalParseResult = BasicResult<ParseState>

Definition at line 647 of file clara.hpp.

ParserResult

using clara::detail::ParserResult = BasicResult<ParseResultType>

Definition at line 646 of file clara.hpp.

Result

using clara::detail::Result = BasicResult<void>

Definition at line 645 of file clara.hpp.

Enumeration Type Documentation

Optionality

enum class clara::detail::Optionality

strong

Enumerator
Optional
Required

Definition at line 805 of file clara.hpp.

{ Optional, Required };

ParseResultType

enum class clara::detail::ParseResultType

strong

Enumerator
Matched
NoMatch
ShortCircuitAll
ShortCircuitSame

Definition at line 625 of file clara.hpp.

                               {
        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
    };

TokenType

enum class clara::detail::TokenType

strong

Enumerator
Option
Argument

Definition at line 430 of file clara.hpp.

                         {
        Option, Argument
    };

Function Documentation

convertInto() [1/3]

auto clara::detail::convertInto ( std::string const & source, bool & target ) -> ParserResult

inline

Definition at line 668 of file clara.hpp.

                                                                                     {
        std::string srcLC = source;
        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
            target = true;
        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
            target = false;
        else
            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
        return ParserResult::ok( ParseResultType::Matched );
    }

Here is the call graph for this function:

convertInto() [2/3]

auto clara::detail::convertInto ( std::string const & source, std::string & target ) -> ParserResult

inline

Definition at line 664 of file clara.hpp.

                                                                                          {
        target = source;
        return ParserResult::ok( ParseResultType::Matched );
    }

Here is the call graph for this function:

convertInto() [3/3]

template<typename T >

auto clara::detail::convertInto ( std::string const & source, T & target ) -> ParserResult

inline

Definition at line 655 of file clara.hpp.

                                                                                  {
        std::stringstream ss;
        ss << source;
        ss >> target;
        if( ss.fail() )
            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
        else
            return ParserResult::ok( ParseResultType::Matched );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

invokeLambda()

template<typename ArgType , typename L >

auto clara::detail::invokeLambda ( L const & lambda, std::string const & arg ) -> ParserResult

inline

Definition at line 770 of file clara.hpp.

                                                                                      {
        ArgType temp{};
        auto result = convertInto( arg, temp );
        return !result
           ? result
           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
    }

Here is the call graph for this function:

isOptPrefix()

auto clara::detail::isOptPrefix ( char c ) -> bool

inline

Definition at line 438 of file clara.hpp.

                                              {
        return c == '-'
#ifdef CLARA_PLATFORM_WINDOWS
            || c == '/'
#endif
        ;
    }

normaliseOpt()

auto clara::detail::normaliseOpt ( std::string const & optName ) -> std::string

inline

Definition at line 951 of file clara.hpp.

                                                                      {
#ifdef CLARA_PLATFORM_WINDOWS
        if( optName[0] == '/' )
            return "-" + optName.substr( 1 );
        else
#endif
            return optName;
    }

Here is the caller graph for this function: