#include <LUPI.hpp>

Public Member Functions
	ArgumentParser (std::string const &a_codeName, std::string const &a_descriptor="")
	~ArgumentParser ()
std::string const &	codeName () const
std::string const &	descriptor () const
template<typename T>
T *	add (std::string const &a_name, std::string const &a_descriptor, int a_minimumNeeded=1, int a_maximumNeeded=1)
ArgumentBase *	add (ArgumentType a_argumentType, std::string const &a_name, std::string const &a_descriptor, int a_minimumNeeded=-2, int a_maximumNeeded=-2)
void	addAlias (std::string const &a_name, std::string const &a_alias)
void	addAlias (ArgumentBase const *const a_argumentBase, std::string const &a_alias)
bool	hasName (std::string const &a_name) const
bool	isOptionalArgument (std::string const &a_name) const
void	parse (int a_argc, char **a_argv, bool a_printArguments=true)
template<typename T>
T *	get (std::size_t a_name)
void	help () const
void	usage () const
virtual void	printStatus (std::string a_indent) const

Detailed Description

The main argument parser class.

Definition at line 132 of file LUPI.hpp.

Constructor & Destructor Documentation

◆ ArgumentParser()

LUPI::ArgumentParser::ArgumentParser	(	std::string const &	a_codeName,
		std::string const &	a_descriptor = "" )

ArgumentParser constructor.

Definition at line 455 of file LUPI_argumentParser.cc.

                                                                                           :
        m_codeName( FileInfo::basenameWithoutExtension( a_codeName ) ),
        m_descriptor( a_descriptor ) {
 
}

◆ ~ArgumentParser()

LUPI::ArgumentParser::~ArgumentParser ( )

ArgumentParser destructor.

Definition at line 465 of file LUPI_argumentParser.cc.

                                 {
 
    for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        delete *argumentIterator;
    }
}

Member Function Documentation

◆ add() [1/2]

ArgumentBase * LUPI::ArgumentParser::add	(	ArgumentType	a_argumentType,
		std::string const &	a_name,
		std::string const &	a_descriptor,
		int	a_minimumNeeded = -2,
		int	a_maximumNeeded = -2 )

Creates an argument instance of type specified by a_argumentType and adds to this.

Parameters

a_argumentType	[in] The type of argument to create.
a_name	[in] The name of the argument.
a_descriptor	[in] The string printed with arugment's help.
a_minimumNeeded	[in] The minimum number of times the argument must be entered.
a_maximumNeeded	[in] The maximum number of times the argument can be entered.

Returns: Returns a pointer to to the created argument instance.

Definition at line 508 of file LUPI_argumentParser.cc.

                                                           {
 
    ArgumentBase *argument = nullptr;
 
    switch( a_argumentType ) {
    case ArgumentType::True :
        argument = new OptionTrue( a_name, a_descriptor );
        break;
    case ArgumentType::False :
        argument = new OptionFalse( a_name, a_descriptor );
        break;
    case ArgumentType::Count :
        argument = new OptionCounter( a_name, a_descriptor );
        break;
    case ArgumentType::Store :
        argument = new OptionStore( a_name, a_descriptor );
        break;
    case ArgumentType::Append :
        argument = new OptionAppend( a_name, a_descriptor, a_minimumNeeded, a_maximumNeeded );
        break;
    default :
        argument = new Positional( a_name, a_descriptor, a_minimumNeeded, a_maximumNeeded );
    }
 
    add2( argument );
 
    return( argument );
}

◆ add() [2/2]

template<typename T>

T * LUPI::ArgumentParser::add	(	std::string const &	a_name,
		std::string const &	a_descriptor,
		int	a_minimumNeeded = 1,
		int	a_maximumNeeded = 1 )

Creates a new argument, adds the argument to this and returns a pointer the the newly created argument.

Parameters

a_name	[in] The name of the argument.
a_descriptor	[in] The argument's description, displayed when the help option is enetered.
a_minimumNeeded	[in] The minimum number of required time this argument must be entered.
a_maximumNeeded	[in] The maximum number of required time this argument must be entered.

Returns: A pointer to the created argument.

Definition at line 172 of file LUPI.hpp.

                                                                                                                                              {
 
    T *argument = new T( a_name, a_descriptor, a_minimumNeeded, a_maximumNeeded );
    add2( argument );
 
    return( argument );
}

◆ addAlias() [1/2]

void LUPI::ArgumentParser::addAlias	(	ArgumentBase const *const	a_argumentBase,
		std::string const &	a_alias )

Adds the alias a_alias to the argument a_argumentBase.

Parameters

a_argumentBase	[in] The argument to add the alias to.
a_alias	[in] The name of the argument to add the alias to.

Definition at line 566 of file LUPI_argumentParser.cc.

                                                                                                   {
 
    addAlias( a_argumentBase->name( ), a_alias );
}

◆ addAlias() [2/2]

void LUPI::ArgumentParser::addAlias	(	std::string const &	a_name,
		std::string const &	a_alias )

Adds the alias a_alias to the argument named a_name.

Parameters

a_name	[in] The name of the argument to add the alias to.
a_alias	[in] The alias name to add.

Definition at line 545 of file LUPI_argumentParser.cc.

                                                                                 {
 
    if( hasName( a_alias ) )
        throw std::runtime_error( "ERROR 1510 in ArgumentParser::addAlias: name '" + a_alias + "' already present." );
 
    for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        if( (*argumentIterator)->hasName( a_name ) ) {
            (*argumentIterator)->addAlias( a_alias );
            return;
        }
    }
    throw std::runtime_error( "ERROR 1520 in ArgumentParser::addAlias: no such argument named '" + a_name + "'." );
}

Referenced by addAlias().

◆ codeName()

std::string const & LUPI::ArgumentParser::codeName ( ) const

inline

Definition at line 145 of file LUPI.hpp.

145{ return( m_codeName ); }

Referenced by usage().

◆ descriptor()

std::string const & LUPI::ArgumentParser::descriptor ( ) const

inline

Definition at line 146 of file LUPI.hpp.

146{ return( m_descriptor ); }

◆ get()

template<typename T>

T * LUPI::ArgumentParser::get ( std::size_t a_name )

◆ hasName()

bool LUPI::ArgumentParser::hasName ( std::string const & a_name ) const

Returns true if name a_name is in this and false otherwise.

Parameters

a_name [in] The name to see check if it exists in this.

Returns: true if name a_name is in this and false otherwise.

Definition at line 596 of file LUPI_argumentParser.cc.

                                                            {
 
    for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        if( (*argumentIterator)->hasName( a_name ) ) return( true );
    }
 
    return( false );
}

Referenced by addAlias().

◆ help()

void LUPI::ArgumentParser::help ( ) const

Prints the help for this.

Definition at line 672 of file LUPI_argumentParser.cc.

                                 {
 
    usage( );
 
    if( m_descriptor != "" ) {
        std::cout << std::endl << "Description:" << std::endl;
        std::cout << "    " << m_descriptor << std::endl;
    }
 
    bool printHeader = true;
    for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        if( (*argumentIterator)->isOptionalArgument( ) ) continue;
 
        if( printHeader ) std::cout << std::endl << "positional arguments:" << std::endl;
        printHeader = false;
 
        std::string line = (*argumentIterator)->name( );
        if( ( (*argumentIterator)->minimumNeeded( ) != (*argumentIterator)->maximumNeeded( ) ) || ( (*argumentIterator)->maximumNeeded( ) != 1 ) )
                    line += " [" + std::to_string( (*argumentIterator)->minimumNeeded( ) ) + "," + std::to_string( (*argumentIterator)->maximumNeeded( ) ) + "]";
        printArgumentDescription( line, (*argumentIterator)->descriptor( ) );
    }
 
    std::cout << std::endl << "optional arguments:" << std::endl;
    std::cout << "  -h, --help                  Show this help message and exit." << std::endl;
    for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        if( !(*argumentIterator)->isOptionalArgument( ) ) continue;
 
        std::string line;
        std::string sep;
        for( auto namesIterator = (*argumentIterator)->names( ).begin( ); namesIterator != (*argumentIterator)->names( ).end( ); ++namesIterator ) {
            line += sep + *namesIterator;
            sep = ", ";
        }
        if( (*argumentIterator)->requiresAValue( ) ) line += " VALUE";
        if( (*argumentIterator)->argumentType( ) == ArgumentType::Append ) {
            if( ( (*argumentIterator)->minimumNeeded( ) != (*argumentIterator)->maximumNeeded( ) ) || ( (*argumentIterator)->maximumNeeded( ) != 1 ) )
                    line += " [" + std::to_string( (*argumentIterator)->minimumNeeded( ) ) + "," + std::to_string( (*argumentIterator)->maximumNeeded( ) ) + "]";
        }
        printArgumentDescription( line, (*argumentIterator)->descriptor( ) );
    }
 
    exit( EXIT_SUCCESS );
}

Referenced by parse().

◆ isOptionalArgument()

bool LUPI::ArgumentParser::isOptionalArgument ( std::string const & a_name ) const

Returns true if name a_name is an optional argument of this and false otherwise.

Parameters

a_name [in] The name to see check if it exists in this.

Returns: true if name a_name is in this and false otherwise.

Definition at line 579 of file LUPI_argumentParser.cc.

                                                                       {
 
    for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        if( (*argumentIterator)->hasName( a_name ) ) return( (*argumentIterator)->argumentType( ) != ArgumentType::Positional );
    }
 
    return( false );
}

Referenced by LUPI::ArgumentBase::parse().

◆ parse()

void LUPI::ArgumentParser::parse	(	int	a_argc,
		char **	a_argv,
		bool	a_printArguments = true )

Parses the list of arguments.

Parameters

a_argc	[in] The number of arguments.
a_argv	[in] The list of arguments.

Definition at line 612 of file LUPI_argumentParser.cc.

                                                                             {
 
    for( int iargc = 1; iargc < a_argc; ++iargc ) {                                       // Check is help requested.
        std::string arg( a_argv[iargc] );
 
        if( ( arg == "-h" ) || ( arg == "--help" ) ) help( );
    }
 
    auto argumentIterator = m_arguments.begin( );      // Find first non-option argument.
    for( ; argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        if( !(*argumentIterator)->isOptionalArgument( ) ) break;
    }
 
    int iargc = 1;
    for( ; iargc < a_argc; ) {
        std::string arg( a_argv[iargc] );
 
        if( arg[0] == '-' ) {                                                           // Need to check if negative number.
            auto argumentIterator2 = m_arguments.begin( );
            for( ; argumentIterator2 != m_arguments.end( ); ++argumentIterator2 ) {
                if( (*argumentIterator2)->hasName( arg ) ) break;
            }
            if( argumentIterator2 == m_arguments.end( ) ) throw std::runtime_error( "ERROR 1600 in ArgumentParser::parse: invalid option '" + arg + "'." );
            iargc = (*argumentIterator2)->parse( *this, iargc, a_argc, a_argv ); }
        else {
            if( argumentIterator == m_arguments.end( ) )
                throw std::runtime_error( "ERROR 1610 in ArgumentParser::parse: additional positional argument found starting at index " 
                        + std::to_string( iargc ) + " (" + arg + ")" );
 
            iargc = (*argumentIterator)->parse( *this, iargc, a_argc, a_argv );
 
            ++argumentIterator;
            for( ; argumentIterator != m_arguments.end( ); ++argumentIterator ) {       // Find next positional arguments.
                if( !(*argumentIterator)->isOptionalArgument( ) ) break;
            }
        }
    }
    for( auto argumentIterator2 = m_arguments.begin( ); argumentIterator2 != m_arguments.end( ); ++argumentIterator2 ) {
        if( static_cast<int>( (*argumentIterator2)->counts( ) ) < (*argumentIterator2)->minimumNeeded( ) ) {
            std::string msg( "arguments for" );
 
            if( (*argumentIterator2)->isOptionalArgument( ) ) msg = "number of option";
            throw std::runtime_error( "ERROR 1620 in ArgumentParser::parse: insufficient " + msg + " '" + (*argumentIterator2)->name( ) 
                    + "' entered. Range of " + std::to_string( (*argumentIterator2)->minimumNeeded( ) ) + " to " 
                    + std::to_string( (*argumentIterator2)->maximumNeeded( ) ) + " required, " 
                    + std::to_string( (*argumentIterator2)->counts( ) ) + " entered." );
        }
    }
 
    if( a_printArguments ) {
        std::cerr << "    " << LUPI::FileInfo::basenameWithoutExtension( m_codeName );
        for( int i1 = 1; i1 < a_argc; i1++ ) std::cerr << " " << a_argv[i1];
        std::cerr << std::endl;
    }
}

◆ printStatus()

void LUPI::ArgumentParser::printStatus ( std::string a_indent ) const

virtual

Returns the usage string for this option.

Parameters

a_indent [in] The amount of indentation to start the first line with.

Returns: The value of a_index + 1.

Definition at line 763 of file LUPI_argumentParser.cc.

                                                           {
 
    for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        (*argumentIterator)->printStatus( a_indent );
    }
}

◆ usage()

void LUPI::ArgumentParser::usage ( ) const

Prints the usage for this.

Definition at line 720 of file LUPI_argumentParser.cc.

                                  {
 
    std::string line( "usage: " );
    line += codeName( );
    std::string indent( "" );
    indent.resize( line.size( ), ' ' );
 
    for( int counter = 0; counter < 2; ++counter ) {
        for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
            if( (*argumentIterator)->isOptionalArgument( ) ) {
                std::string optionUsage( (*argumentIterator)->usage( counter == 0 ) );
 
                if( ( line.size( ) + optionUsage.size( ) ) > maxPrintLineWidth ) {
                    std::cout << line << std::endl;
                    line = indent;
                }
                line += optionUsage;
            }
        }
    }
 
    for( auto argumentIterator = m_arguments.begin( ); argumentIterator != m_arguments.end( ); ++argumentIterator ) {
        if( (*argumentIterator)->isOptionalArgument( ) ) continue;
        std::string optionUsage( (*argumentIterator)->usage( false ) );
 
        if( ( line.size( ) + optionUsage.size( ) ) > maxPrintLineWidth ) {
            std::cout << line << std::endl;
            line = indent;
        }
        line += optionUsage;
    }
    if( line.size( ) > indent.size( ) ) std::cout << line << std::endl;
    std::cout << std::endl;
}

Referenced by help().

The documentation for this class was generated from the following files:

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ArgumentParser()

◆ ~ArgumentParser()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ addAlias() [1/2]

◆ addAlias() [2/2]

◆ codeName()

◆ descriptor()

◆ get()

◆ hasName()

◆ help()

◆ isOptionalArgument()

◆ parse()

◆ printStatus()

◆ usage()