clara::detail::Parser Struct Reference

#include <clara.hpp>

Inheritance diagram for clara::detail::Parser:

Collaboration diagram for clara::detail::Parser:

Public Member Functions
auto	operator|= (ExeName const &exeName) -> Parser &
auto	operator|= (Arg const &arg) -> Parser &
auto	operator|= (Opt const &opt) -> Parser &
auto	operator|= (Parser const &other) -> Parser &
template<typename T >
auto	operator| (T const &other) const -> Parser
template<typename T >
auto	operator+= (T const &other) -> Parser &
template<typename T >
auto	operator+ (T const &other) const -> Parser
auto	getHelpColumns () const -> std::vector< HelpColumns >
void	writeToStream (std::ostream &os) const
auto	validate () const -> Result override
auto	parse (std::string const &exeName, TokenStream const &tokens) const -> InternalParseResult override
auto	parse (Args const &args) const -> InternalParseResult
Public Member Functions inherited from clara::detail::ParserBase
virtual	~ParserBase ()=default
virtual auto	cardinality () const -> size_t
auto	parse (Args const &args) const -> InternalParseResult

Public Attributes
ExeName	m_exeName
std::vector< Opt >	m_options
std::vector< Arg >	m_args

Friends
auto	operator<< (std::ostream &os, Parser const &parser) -> std::ostream &

Detailed Description

Definition at line 1076 of file clara.hpp.

Member Function Documentation

getHelpColumns()

auto clara::detail::Parser::getHelpColumns ( ) const -> std::vector<HelpColumns>

inline

Definition at line 1114 of file clara.hpp.

                                                              {
            std::vector<HelpColumns> cols;
            for (auto const &o : m_options) {
                auto childCols = o.getHelpColumns();
                cols.insert( cols.end(), childCols.begin(), childCols.end() );
            }
            return cols;
        }

Here is the caller graph for this function:

operator+()

template<typename T >

auto clara::detail::Parser::operator+ ( T const & other ) const -> Parser

inline

Definition at line 1112 of file clara.hpp.

{ return operator|( other ); }

Here is the call graph for this function:

operator+=()

template<typename T >

auto clara::detail::Parser::operator+= ( T const & other ) -> Parser &

inline

Definition at line 1110 of file clara.hpp.

{ return operator|=( other ); }

Here is the call graph for this function:

operator|()

template<typename T >

auto clara::detail::Parser::operator| ( T const & other ) const -> Parser

inline

Definition at line 1104 of file clara.hpp.

                                                         {
            return Parser( *this ) |= other;
        }

Here is the caller graph for this function:

operator|=() [1/4]

auto clara::detail::Parser::operator|= ( Arg const & arg ) -> Parser &

inline

Definition at line 1087 of file clara.hpp.

                                                      {
            m_args.push_back(arg);
            return *this;
        }

operator|=() [2/4]

auto clara::detail::Parser::operator|= ( ExeName const & exeName ) -> Parser &

inline

Definition at line 1082 of file clara.hpp.

                                                              {
            m_exeName = exeName;
            return *this;
        }

Here is the caller graph for this function:

operator|=() [3/4]

auto clara::detail::Parser::operator|= ( Opt const & opt ) -> Parser &

inline

Definition at line 1092 of file clara.hpp.

                                                      {
            m_options.push_back(opt);
            return *this;
        }

operator|=() [4/4]

auto clara::detail::Parser::operator|= ( Parser const & other ) -> Parser &

inline

Definition at line 1097 of file clara.hpp.

                                                           {
            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
            return *this;
        }

parse() [1/2]

auto clara::detail::ParserBase::parse ( Args const & args ) const -> InternalParseResult

inline

Definition at line 816 of file clara.hpp.

                                                                    {
            return parse( args.exeName(), TokenStream( args ) );
        }

parse() [2/2]

auto clara::detail::Parser::parse ( std::string const & exeName, TokenStream const & tokens ) const -> InternalParseResult

inlineoverridevirtual

Implements clara::detail::ParserBase.

Definition at line 1185 of file clara.hpp.

                                                                                                                {
 
            struct ParserInfo {
                ParserBase const* parser = nullptr;
                size_t count = 0;
            };
            const size_t totalParsers = m_options.size() + m_args.size();
            assert( totalParsers < 512 );
            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
            ParserInfo parseInfos[512];
 
            {
                size_t i = 0;
                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
            }
 
            m_exeName.set( exeName );
 
            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
            while( result.value().remainingTokens() ) {
                bool tokenParsed = false;
 
                for( size_t i = 0; i < totalParsers; ++i ) {
                    auto&  parseInfo = parseInfos[i];
                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
                        if (!result)
                            return result;
                        if (result.value().type() != ParseResultType::NoMatch) {
                            tokenParsed = true;
                            ++parseInfo.count;
                            break;
                        }
                    }
                }
 
                if( result.value().type() == ParseResultType::ShortCircuitAll )
                    return result;
                if( !tokenParsed )
                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
            }
            // !TBD Check missing required options
            return result;
        }

Here is the call graph for this function:

validate()

auto clara::detail::Parser::validate ( ) const -> Result

inlineoverridevirtual

Reimplemented from clara::detail::ParserBase.

Definition at line 1169 of file clara.hpp.

                                                 {
            for( auto const &opt : m_options ) {
                auto result = opt.validate();
                if( !result )
                    return result;
            }
            for( auto const &arg : m_args ) {
                auto result = arg.validate();
                if( !result )
                    return result;
            }
            return Result::ok();
        }

Here is the call graph for this function:

writeToStream()

void clara::detail::Parser::writeToStream ( std::ostream & os ) const

inline

Definition at line 1123 of file clara.hpp.

                                                   {
            if (!m_exeName.name().empty()) {
                os << "usage:\n" << "  " << m_exeName.name() << " ";
                bool required = true, first = true;
                for( auto const &arg : m_args ) {
                    if (first)
                        first = false;
                    else
                        os << " ";
                    if( arg.isOptional() && required ) {
                        os << "[";
                        required = false;
                    }
                    os << "<" << arg.hint() << ">";
                    if( arg.cardinality() == 0 )
                        os << " ... ";
                }
                if( !required )
                    os << "]";
                if( !m_options.empty() )
                    os << " options";
                os << "\n\nwhere options are:" << std::endl;
            }
 
            auto rows = getHelpColumns();
            size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
            size_t optWidth = 0;
            for( auto const &cols : rows )
                optWidth = (std::max)(optWidth, cols.left.size() + 2);
 
            optWidth = (std::min)(optWidth, consoleWidth/2);
 
            for( auto const &cols : rows ) {
                auto row =
                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
                        TextFlow::Spacer(4) +
                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
                os << row << std::endl;
            }
        }

Here is the call graph for this function:

Friends And Related Symbol Documentation

operator<<

auto operator<< ( std::ostream & os, Parser const & parser ) -> std::ostream&

friend

Definition at line 1164 of file clara.hpp.

                                                                                      {
            parser.writeToStream( os );
            return os;
        }

Member Data Documentation

m_args

std::vector<Arg> clara::detail::Parser::m_args

Definition at line 1080 of file clara.hpp.

m_exeName

ExeName clara::detail::Parser::m_exeName

mutable

Definition at line 1078 of file clara.hpp.

m_options

std::vector<Opt> clara::detail::Parser::m_options

Definition at line 1079 of file clara.hpp.

---

The documentation for this struct was generated from the following file:

• libraries/sys-vm/external/Catch2/third_party/clara.hpp