LUPI::ArgumentBase Class Reference

#include <LUPI.hpp>

Inheritance diagram for LUPI::ArgumentBase:

Public Member Functions
	ArgumentBase (ArgumentType a_argumentType, std::string const &a_name, std::string const &a_descriptor, int a_minimumNeeded, int a_maximumNeeded)
virtual	~ArgumentBase ()=0
ArgumentType	argumentType () const
std::string const &	name () const
std::vector< std::string > const &	names ()
bool	hasName (std::string const &a_name) const
std::string const &	descriptor () const
int	minimumNeeded () const
int	maximumNeeded () const
std::size_t	counts () const
virtual std::string const &	value (std::size_t a_index=0) const
std::vector< std::string > const &	values () const
virtual bool	isOptionalArgument () const
virtual bool	requiresAValue () const
virtual int	parse (ArgumentParser const &a_argumentParser, int a_index, int a_argc, char **a_argv)
std::string	usage (bool a_requiredOption) const
void	printStatus (std::string a_indent) const

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

Detailed Description

Base class for argument and option sub-classes.

Definition at line 186 of file LUPI.hpp.

Constructor & Destructor Documentation

ArgumentBase()

LUPI::ArgumentBase::ArgumentBase	(	ArgumentType	a_argumentType,
		std::string const &	a_name,
		std::string const &	a_descriptor,
		int	a_minimumNeeded,
		int	a_maximumNeeded )

ArgumentBase constructor.

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.

Definition at line 34 of file LUPI_argumentParser.cc.

                                                                                                                                                          :
        m_argumentType( a_argumentType ),
        m_names( ),
        m_descriptor( a_descriptor ),
        m_minimumNeeded( a_minimumNeeded ),
        m_maximumNeeded( a_maximumNeeded ),
        m_counts( 0 ) {
 
    if( m_minimumNeeded < 0 ) throw std::runtime_error( "ERROR 1000 in ArgumentBase::ArgumentBase: m_minimumNeeded must not be negative." );
    if( m_maximumNeeded > -1 ) {
        if( m_minimumNeeded > m_maximumNeeded )
            throw std::runtime_error( "ERROR 1010 in ArgumentBase::ArgumentBase: for argument '" + a_name + "' m_maximumNeeded less than m_minimumNeeded." );
    }
 
    if( m_argumentType == ArgumentType::Positional ) {
        if( a_name[0] == '-' )
            throw std::runtime_error( "ERROR 1020 in ArgumentBase::ArgumentBase: positional argument name '" + a_name + "' cannot start with a '-'." );
    }
 
    addAlias( a_name );
}

Referenced by LUPI::OptionAppend::OptionAppend(), LUPI::OptionBoolean::OptionBoolean(), LUPI::OptionCounter::OptionCounter(), LUPI::OptionStore::OptionStore(), and LUPI::Positional::Positional().

~ArgumentBase()

LUPI::ArgumentBase::~ArgumentBase ( )

pure virtual

ArgumentBase destructor.

Definition at line 60 of file LUPI_argumentParser.cc.

                             {
 
}

Member Function Documentation

argumentType()

ArgumentType LUPI::ArgumentBase::argumentType ( ) const

inline

Definition at line 207 of file LUPI.hpp.

{ return( m_argumentType ); }

counts()

std::size_t LUPI::ArgumentBase::counts ( ) const

inline

Definition at line 214 of file LUPI.hpp.

{ return( m_counts ); }

Referenced by parse(), LUPI::OptionBoolean::printStatus2(), LUPI::OptionCounter::printStatus2(), and LUPI::OptionStore::printStatus3().

descriptor()

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

inline

Definition at line 211 of file LUPI.hpp.

{ return( m_descriptor ); }

hasName()

bool LUPI::ArgumentBase::hasName

(

std::string const &

a_name

)

const

Returns true if a_name is one of the names for this and false otherwise.

Parameters

a_name

[in] The name to search for.

Returns

Returns true if a_name is a match for one of the names for this and false otherwise.

Definition at line 72 of file LUPI_argumentParser.cc.

                                                          {
 
    for( auto iter = m_names.begin( ); iter != m_names.end( ); ++iter ) {
        if( a_name == *iter ) return( true );
    }
    return( false );
}

isOptionalArgument()

virtual bool LUPI::ArgumentBase::isOptionalArgument ( ) const

inlinevirtual

Reimplemented in LUPI::Positional.

Definition at line 218 of file LUPI.hpp.

{ return( true ); }

Referenced by usage().

maximumNeeded()

int LUPI::ArgumentBase::maximumNeeded ( ) const

inline

Definition at line 213 of file LUPI.hpp.

{ return( m_maximumNeeded ); }

Referenced by parse().

minimumNeeded()

int LUPI::ArgumentBase::minimumNeeded ( ) const

inline

Definition at line 212 of file LUPI.hpp.

{ return( m_minimumNeeded ); }

name()

std::string const & LUPI::ArgumentBase::name ( ) const

inline

Definition at line 208 of file LUPI.hpp.

{ return( m_names[0] ); }

Referenced by LUPI::ArgumentParser::addAlias(), parse(), printStatus(), usage(), and value().

names()

std::vector< std::string > const & LUPI::ArgumentBase::names ( )

inline

Definition at line 209 of file LUPI.hpp.

{ return( m_names ); }

parse()

int LUPI::ArgumentBase::parse ( ArgumentParser const & a_argumentParser, int a_index, int a_argc, char ** a_argv )

virtual

Counts each time a specific argument is found.

Parameters

a_index	[in] The index of the current command argument in a_argv.
a_argc	[in] The number of command arguments.
a_argv	[in] The list of command arguments.

Returns

The value of a_index + 1.

Definition at line 127 of file LUPI_argumentParser.cc.

                                                                                                        {
 
    ++m_counts;
    if( m_argumentType != ArgumentType::Positional ) ++a_index;
 
    if( ( m_argumentType == ArgumentType::Store ) || ( m_argumentType == ArgumentType::Append ) || ( m_argumentType == ArgumentType::Positional ) ) {
        int maximumNeeded1 = maximumNeeded( );
        if( m_argumentType == ArgumentType::Positional ) {
            if( maximumNeeded1 < 0 ) maximumNeeded1 = a_argc; }
        else {
            if( ( maximumNeeded1 < static_cast<int>( counts( ) ) ) && ( maximumNeeded1 > -1 ) )
                throw std::runtime_error( "ERROR 1220 in ArgumentBase::parse: too many values for optional argument " + name( ) + " entered." );
            maximumNeeded1 = 1;
        }
 
        for( int index = 0; index < maximumNeeded1; ++index ) {
            if( a_index == a_argc ) {
                if( m_argumentType == ArgumentType::Positional ) break;
                throw std::runtime_error( "ERROR 1200 in ArgumentBase::parse: missing value for argument " + name( ) + "." );
            }
            if( ( m_argumentType == ArgumentType::Positional ) && a_argumentParser.isOptionalArgument( a_argv[a_index] ) ) break;
 
            m_values.push_back( a_argv[a_index] );
            if( index > 0 ) ++m_counts;
            ++a_index;
        }
    }
 
    return( a_index );
}

printStatus()

void LUPI::ArgumentBase::printStatus

(

std::string

a_indent

)

const

Prints generic information about the status of this.

Parameters

a_indent

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

Returns

The value of a_index + 1.

Definition at line 203 of file LUPI_argumentParser.cc.

                                                         {
 
    std::string name1 = name( );
    if( name1.size( ) < 32 ) name1.resize( 32, ' ' );
 
    std::cout << a_indent << name1 << ": number entered " << std::to_string( m_counts )
            << "; number needed (" << std::to_string( m_minimumNeeded ) << "," << std::to_string( m_maximumNeeded ) << ")" 
            << printStatus2( ) << std::endl;
    printStatus3( a_indent + "    " );
}

requiresAValue()

virtual bool LUPI::ArgumentBase::requiresAValue ( ) const

inlinevirtual

Reimplemented in LUPI::OptionAppend, LUPI::OptionStore, and LUPI::Positional.

Definition at line 219 of file LUPI.hpp.

{ return( false ); }

Referenced by usage().

usage()

std::string LUPI::ArgumentBase::usage

(

bool

a_requiredOption

)

const

Returns the usage string for this argument.

Parameters

a_requiredOption

[in] The index of the current command argument in a_argv.

Returns

The value of a_index + 1.

Definition at line 166 of file LUPI_argumentParser.cc.

                                                           {
 
    std::string usageString;
 
    if( isOptionalArgument( ) ) {
        if( a_requiredOption ) {
            if( m_minimumNeeded != 0 ) return( usageString ); }
        else {
            if( m_minimumNeeded == 0 ) return( usageString );
        }
    }
    usageString += " ";
 
    std::string value;
    if( isOptionalArgument( ) && requiresAValue( ) ) value = " VALUE";
    if( isOptionalArgument( ) && ( m_minimumNeeded == 0 ) ) {
        usageString += "[" + name( ) + value + "]"; }
    else {
        usageString += name( ) + value;
    }
 
    if( !isOptionalArgument( ) ) {
        if( ( m_minimumNeeded != 1 ) || ( m_maximumNeeded != 1 ) )
            usageString += "[" + std::to_string( m_minimumNeeded ) + "," + std::to_string( m_maximumNeeded ) + "]";
    }
 
    return( usageString );
}

value()

std::string const & LUPI::ArgumentBase::value ( std::size_t a_index = 0 ) const

virtual

Returns the value at index a_index. If a_index exceeds the number of values entered, a throw is executed.

Parameters

a_index

[in] The 0-based index into the m_values std::vector whose content is returned.

Returns

Returns the value entered at index a_index.

Reimplemented in LUPI::OptionStore.

Definition at line 88 of file LUPI_argumentParser.cc.

                                                              {
 
    if( ( m_argumentType == ArgumentType::True ) || ( m_argumentType == ArgumentType::False ) || ( m_argumentType == ArgumentType::Count ) )
        throw Exception( "Argument type for " + name( ) + " does not support calling value() method." );
 
    if( a_index >= m_values.size( ) ) throw Exception( "Index = " + std::to_string( a_index ) + " out-of-bounds for argument \"" + name( ) + "\"." );
 
    return( m_values[a_index] );
}

Referenced by usage(), and LUPI::OptionStore::value().

values()

std::vector< std::string > const & LUPI::ArgumentBase::values ( ) const

inline

Definition at line 217 of file LUPI.hpp.

{ return( m_values ); }

Referenced by LUPI::OptionAppend::printStatus3(), LUPI::Positional::printStatus3(), and LUPI::OptionStore::value().

Friends And Related Symbol Documentation

ArgumentParser::addAlias

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

friend

---

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

• LUPI.hpp
• LUPI_argumentParser.cc