command.hpp

Go to the documentation of this file.

 
#ifndef ARGS__COMMAND_HPP__INCLUDED
#define ARGS__COMMAND_HPP__INCLUDED
 
// Args include.
#include "api.hpp"
#include "group_iface.hpp"
#include "utils.hpp"
#include "context.hpp"
#include "value_utils.hpp"
#include "enums.hpp"
#include "types.hpp"
 
 
namespace Args {
 
//
// Command
//
 
class Command
    :   public GroupIface
{
    friend class CmdLine;
    friend class HelpPrinter;
    friend class Help;
 
public:
    template< typename T >
    explicit Command( T && nm,
        ValueOptions opt = ValueOptions::NoValue,
        bool isSubCommandRequired = false )
        :   GroupIface( std::forward< T > ( nm ) )
        ,   m_opt( opt )
        ,   m_isDefined( false )
        ,   m_isSubCommandRequired( isSubCommandRequired )
        ,   m_subCommand( nullptr )
    {
        if( details::isArgument( name() ) || details::isFlag( name() ) )
            throw BaseException( String( SL( "Command's name can't "
                "start with \"-\" whereas you are trying to set name to \"" ) ) +
                name() + SL( "\"." ) );
 
        if( name().empty() )
            throw BaseException(
                String( SL( "Command can't be with empty name." ) ) );
 
        switch( m_opt )
        {
            case ValueOptions::OneValue :
            {
                m_valueSpecifier = SL( "arg" );
            }
                break;
 
            case ValueOptions::ManyValues :
            {
                m_valueSpecifier = SL( "args" );
            }
                break;
 
            default :
                break;
        }
    }
 
    virtual ~Command()
    {
    }
 
    ArgType type() const override
    {
        return ArgType::Command;
    }
 
    bool isDefined() const override
    {
        return m_isDefined;
    }
 
    bool isWithValue() const override
    {
        return ( m_opt == ValueOptions::OneValue ||
            m_opt == ValueOptions::ManyValues );
    }
 
    void setRequired( bool on = true ) override
    {
        UNUSED( on )
    }
 
    const String & valueSpecifier() const override
    {
        return m_valueSpecifier;
    }
    void setValueSpecifier( const String & vs )
    {
        m_valueSpecifier = vs;
    }
 
    const String & description() const override
    {
        return m_description;
    }
    void setDescription( const String & desc )
    {
        m_description = desc;
    }
 
    const String & longDescription() const override
    {
        if( !m_longDescription.empty() )
            return m_longDescription;
        else
            return m_description;
    }
    void setLongDescription( const String & desc )
    {
        m_longDescription = desc;
    }
 
    const String & value() const
    {
        if( !m_values.empty() )
            return m_values.front();
        else if( !m_defaultValues.empty() )
            return m_defaultValues.front();
        else
            return details::DummyString<>::c_string;
    }
 
    const StringList & values() const
    {
        if( !m_values.empty() )
            return m_values;
        else
            return m_defaultValues;
    }
 
    const String & defaultValue() const
    {
        if( !m_defaultValues.empty() )
            return m_defaultValues.front();
        else
            return details::DummyString<>::c_string;
    }
 
    void setDefaultValue( const String & v )
    {
        m_defaultValues.push_back( v );
    }
 
    const StringList & defaultValues() const
    {
        return m_defaultValues;
    }
 
    void setDefaultValues( const StringList & v )
    {
        m_defaultValues = v;
    }
 
    bool isMisspelledName(
        const String & nm,
        StringList & possibleNames ) const override
    {
        bool ret = false;
 
        if( details::isMisspelledName( nm, name() ) )
        {
            possibleNames.push_back( name() );
 
            ret = true;
        }
 
        if( GroupIface::isMisspelledName( nm, possibleNames ) )
            return true;
        else
            return ret;
    }
 
    bool isMisspelledCommand(
        const String & nm,
        StringList & possibleNames ) const
    {
        if( details::isMisspelledName( nm, name() ) )
        {
            possibleNames.push_back( name() );
 
            return true;
        }
        else
            return false;
    }
 
    void clear() override
    {
        m_isDefined = false;
 
        m_values.clear();
 
        GroupIface::clear();
    }
 
    using GroupIface::addArg;
 
    void addArg( ArgPtr arg ) override
    {
        if( arg->type() == ArgType::Command && m_opt != ValueOptions::NoValue )
            throw BaseException( String( SL( "Addition of commands to command with "
                "value is disallowed." ) ) );
 
        if( std::find( m_children.cbegin(), m_children.cend(), arg ) ==
            m_children.cend() )
        {
            if( cmdLine() )
                arg->setCmdLine( cmdLine() );
 
            m_children.push_back( std::move( arg ) );
        }
    }
 
protected:
    ArgIface * findArgument(
        const String & n ) override
    {
        if( name() == n )
            return this;
        else
            return nullptr;
    }
 
    ArgIface * findChild(
        const String & name )
    {
        auto * arg = GroupIface::findArgument( name );
 
        if( !arg && m_subCommand )
            return m_subCommand->findChild( name );
 
        return arg;
    }
 
    void process(
        Context & ctx ) override
    {
        m_isDefined = true;
 
        switch( m_opt )
        {
            case ValueOptions::ManyValues :
            {
                eatValues( ctx, m_values,
                    String( SL( "Command \"" ) ) +
                        name() + SL( "\" requires value that wasn't presented." ),
                    cmdLine() );
            }
                break;
 
            case ValueOptions::OneValue :
            {
                m_values.push_back( eatOneValue( ctx,
                    String( SL( "Command \"" ) ) + name() +
                        SL( "\" requires value that wasn't presented." ),
                    cmdLine() ) );
            }
                break;
 
            default :
                break;
        }
    }
 
    void checkCorrectnessBeforeParsing(
        StringList & flags,
        StringList & names ) const override
    {
        if( details::isCorrectName( name() ) )
        {
            auto it = std::find( names.begin(), names.end(), name() );
 
            if( it != names.end() )
                throw BaseException( String( SL( "Redefinition of command "
                    "with name \"" ) ) + name() + SL( "\"." ) );
            else
                names.push_back( name() );
        }
        else
            throw BaseException( String( SL( "Disallowed name \"" ) ) +
                name() + SL( "\" for the command." ) );
 
        StringList ftmp = flags;
        StringList ntmp = names;
 
        GroupIface::checkCorrectnessBeforeParsing( ftmp, ntmp );
    }
 
    void checkCorrectnessAfterParsing() const override
    {
        if( isDefined() )
            GroupIface::checkCorrectnessAfterParsing();
 
        if( isDefined() && m_isSubCommandRequired && !m_subCommand )
            throw BaseException( String( SL( "Wasn't defined required sub-command of command \"" ) ) +
                name() + SL( "\"." ) );
    }
 
    void setCurrentSubCommand( Command * sub )
    {
        m_subCommand = sub;
    }
 
private:
    DISABLE_COPY( Command )
 
    
    ValueOptions m_opt;
    String m_valueSpecifier;
    String m_description;
    String m_longDescription;
    bool m_isDefined;
    bool m_isSubCommandRequired;
    StringList m_values;
    StringList m_defaultValues;
    Command * m_subCommand;
}; // class Command
 
} /* namespace Args */
 
#endif // ARGS__COMMAND_HPP__INCLUDED