arg.hpp

Go to the documentation of this file.

 
#ifndef ARGS__ARG_HPP__INCLUDED
#define ARGS__ARG_HPP__INCLUDED
 
// Args include.
#include "arg_iface.hpp"
#include "utils.hpp"
#include "context.hpp"
#include "exceptions.hpp"
#include "value_utils.hpp"
#include "types.hpp"
 
// C++ include.
#include <algorithm>
 
 
namespace Args {
 
//
// Arg
//
 
class Arg
    :   public ArgIface
{
public:
    template< typename T >
    Arg(
        Char flag,
        T && name,
        bool isWithValue = false,
        bool isRequired = false );
 
    explicit Arg(
        Char flag,
        bool isWithValue = false,
        bool isRequired = false );
 
    template< typename T >
    explicit Arg(
        T && name,
        bool isWithValue = false,
        bool isRequired = false );
 
    virtual ~Arg();
 
    ArgType type() const override
    {
        return ArgType::Arg;
    }
 
    String name() const override;
 
    bool isWithValue() const override;
    void setWithValue( bool on = true );
 
    bool isRequired() const override;
    void setRequired( bool on = true );
 
    bool isDefined() const override;
    void setDefined( bool on = true );
 
    virtual const String & value() const;
    virtual void setValue( const String & v );
 
    const String & flag() const override;
    void setFlag( Char f );
 
    const String & argumentName() const override;
    void setArgumentName( const String & name );
 
    const String & valueSpecifier() const override;
    void setValueSpecifier( const String & vs );
 
    const String & description() const override;
    void setDescription( const String & desc );
 
    const String & longDescription() const override;
    void setLongDescription( const String & desc );
 
    virtual const String & defaultValue() const
    {
        return m_defaultValue;
    }
 
    virtual void setDefaultValue( const String & v )
    {
        m_defaultValue = v;
    }
 
    bool isMisspelledName(
        const String & name,
        StringList & possibleNames ) const override
    {
        if( !argumentName().empty() )
        {
            if( details::isMisspelledName( name,
                String( SL( "--" ) ) + argumentName() ) )
            {
                possibleNames.push_back( String( SL( "--" ) ) + argumentName() );
 
                return true;
            }
        }
 
        return false;
    }
 
    void clear() override
    {
        setDefined( false );
 
        m_value.clear();
    }
 
protected:
    ArgIface * findArgument(
        const String & name ) override
    {
        if( details::isArgument( name ) && name.substr( 2 ) == m_name )
            return this;
        else if( details::isFlag( name ) && name.substr( 1 ) == m_flag )
            return this;
        else
            return nullptr;
    }
 
    void process(
        Context & context ) override;
 
    void checkCorrectnessBeforeParsing(
        StringList & flags,
        StringList & names ) const override;
 
    void checkCorrectnessAfterParsing() const override;
 
private:
    DISABLE_COPY( Arg )
 
    
    bool m_isWithValue;
    bool m_isRequired;
    bool m_isDefined;
    String m_value;
    String m_flag;
    String m_name;
    String m_valueSpecifier;
    String m_description;
    String m_longDescription;
    String m_defaultValue;
}; // class Arg
 
 
//
// Arg
//
 
template< typename T >
Arg::Arg( Char flag, T && name,
    bool isWithValue, bool isRequired )
    :   m_isWithValue( isWithValue )
    ,   m_isRequired( isRequired )
    ,   m_isDefined( false )
    ,   m_flag( 1, flag )
    ,   m_name( std::forward< T > ( name ) )
    ,   m_valueSpecifier( SL( "arg" ) )
{
}
 
inline
Arg::Arg( Char flag,
    bool isWithValue, bool isRequired )
    :   m_isWithValue( isWithValue )
    ,   m_isRequired( isRequired )
    ,   m_isDefined( false )
    ,   m_flag( 1, flag )
    ,   m_valueSpecifier( SL( "arg" ) )
{
}
 
template< typename T >
Arg::Arg( T && name,
    bool isWithValue, bool isRequired )
    :   m_isWithValue( isWithValue )
    ,   m_isRequired( isRequired )
    ,   m_isDefined( false )
    ,   m_name( std::forward< T > ( name ) )
    ,   m_valueSpecifier( SL( "arg" ) )
{
}
 
inline
Arg::~Arg()
{
}
 
inline void
Arg::process( Context & context )
{
    if( !isDefined() )
    {
        if( !isWithValue() )
            setDefined( true );
        else
        {
            setValue( eatOneValue( context,
                String( SL( "Argument \"" ) ) + name() +
                    SL( "\" requires value that wasn't presented." ),
                cmdLine() ) );
 
            setDefined( true );
        }
    }
    else
        throw BaseException( String( SL( "Argument \"" ) ) +
            name() + SL( "\" already defined." ) );
}
 
inline String
Arg::name() const
{
    if( !m_name.empty() )
        return SL( "--" ) + m_name;
    else
        return SL( "-" ) + m_flag;
}
 
inline void
Arg::checkCorrectnessBeforeParsing( StringList & flags,
    StringList & names ) const
{
    if( !m_flag.empty() )
    {
        if( details::isCorrectFlag( m_flag ) )
        {
            const String flag = String( SL( "-" ) ) + m_flag;
 
            auto it = std::find( flags.begin(), flags.end(), flag );
 
            if( it != flags.end() )
                throw BaseException( String( SL( "Redefinition of argument "
                    "with flag \"" ) ) + flag + SL( "\"." ) );
            else
                flags.push_back( flag );
        }
        else
            throw BaseException( String( SL( "Disallowed flag \"-" ) ) +
                m_flag + SL( "\"." ) );
    }
 
    if( !m_name.empty() )
    {
        if( details::isCorrectName( m_name ) )
        {
            const String name = String( SL( "--" ) ) + m_name;
 
            auto it = std::find( names.begin(), names.end(), name );
 
            if( it != names.end() )
                throw BaseException( String( SL( "Redefinition of argument "
                    "with name \"" ) ) + name + SL( "\"." ) );
            else
                names.push_back( name );
        }
        else
            throw BaseException( String( SL( "Disallowed name \"--" ) ) +
                m_name + SL( "\"." ) );
    }
 
    if( m_flag.empty() && m_name.empty() )
        throw BaseException( String( SL( "Arguments with empty flag and name "
            "are disallowed." ) ) );
}
 
inline void
Arg::checkCorrectnessAfterParsing() const
{
    if( isRequired() && !isDefined() )
        throw BaseException( String( SL( "Undefined required argument \"" ) ) +
            name() + SL( "\"." ) );
}
 
inline bool
Arg::isWithValue() const
{
    return m_isWithValue;
}
 
inline void
Arg::setWithValue( bool on )
{
    m_isWithValue = on;
}
 
inline bool
Arg::isRequired() const
{
    return m_isRequired;
}
 
inline void
Arg::setRequired( bool on )
{
    m_isRequired = on;
}
 
inline bool
Arg::isDefined() const
{
    return m_isDefined;
}
 
inline void
Arg::setDefined( bool on )
{
    m_isDefined = on;
}
 
inline const String &
Arg::value() const
{
    if( !m_value.empty() )
        return m_value;
    else
        return m_defaultValue;
}
 
inline void
Arg::setValue( const String & v )
{
    m_value = v;
}
 
inline const String &
Arg::flag() const
{
    return m_flag;
}
 
inline void
Arg::setFlag( Char f )
{
    m_flag = String( 1, f );
}
 
inline const String &
Arg::argumentName() const
{
    return m_name;
}
 
inline void
Arg::setArgumentName( const String & name )
{
    m_name = name;
}
 
inline const String &
Arg::valueSpecifier() const
{
    return m_valueSpecifier;
}
 
inline void
Arg::setValueSpecifier( const String & vs )
{
    m_valueSpecifier = vs;
}
 
inline const String &
Arg::description() const
{
    return m_description;
}
 
inline void
Arg::setDescription( const String & desc )
{
    m_description = desc;
}
 
inline const String &
Arg::longDescription() const
{
    if( !m_longDescription.empty() )
        return m_longDescription;
    else
        return m_description;
}
 
inline void
Arg::setLongDescription( const String & desc )
{
    m_longDescription = desc;
}
 
} /* namespace Args */
 
#endif // ARGS__ARG_HPP__INCLUDED