group_iface.hpp

Go to the documentation of this file.

 
#ifndef ARGS__GROUP_IFACE_HPP__INCLUDED
#define ARGS__GROUP_IFACE_HPP__INCLUDED
 
// Args include.
#include "arg_iface.hpp"
#include "utils.hpp"
#include "exceptions.hpp"
#include "types.hpp"
#include "utils.hpp"
 
// C++ include.
#include <vector>
#include <type_traits>
#include <algorithm>
#include <utility>
#include <memory>
 
 
namespace Args {
 
class Command;
 
 
//
// GroupIface
//
 
class GroupIface
    :   public ArgIface
{
public:
    using ArgPtr = std::unique_ptr< ArgIface, details::Deleter< ArgIface > >;
    using Arguments = std::vector< ArgPtr >;
 
    template< typename T >
    explicit GroupIface( T && name,
        bool required = false )
        :   m_name( std::forward< T > ( name ) )
        ,   m_required( required )
    {
    }
 
    virtual ~GroupIface()
    {
    }
 
    const Arguments & children() const
    {
        return m_children;
    }
 
    void addArg( ArgIface & arg )
    {
        addArg( ArgPtr( &arg, details::Deleter< ArgIface > ( false ) ) );
    }
 
    void addArg( ArgIface * arg )
    {
        addArg( ArgPtr( arg, details::Deleter< ArgIface > ( false ) ) );
    }
 
    virtual void addArg( ArgPtr arg )
    {
        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 ) );
        }
    }
 
    String name() const override
    {
        return m_name;
    }
 
    bool isWithValue() const override
    {
        return false;
    }
 
    bool isRequired() const override
    {
        return m_required;
    }
 
    virtual void setRequired( bool on = true )
    {
        m_required = on;
    }
 
    const String & flag() const override
    {
        return details::DummyString<>::c_string;
    }
 
    const String & argumentName() const override
    {
        return details::DummyString<>::c_string;
    }
 
    const String & valueSpecifier() const override
    {
        return details::DummyString<>::c_string;
    }
 
    const String & description() const override
    {
        return details::DummyString<>::c_string;
    }
 
    const String & longDescription() const override
    {
        return details::DummyString<>::c_string;
    }
 
    void clear() override
    {
        std::for_each( children().begin(), children().end(),
            [ & ] ( const auto & ch ) { ch->clear(); } );
    }
 
protected:
    ArgIface * findArgument(
        const String & name ) override
    {
        for( const auto & arg : details::asConst( m_children ) )
        {
            ArgIface * tmp = arg->findArgument( name );
 
            if( tmp != nullptr )
                return tmp;
        }
 
        return nullptr;
    }
 
    void process(
        Context & ) override
    {
    }
 
    void checkCorrectnessBeforeParsing(
        StringList & flags,
        StringList & names ) const override
    {
        for( const auto & arg : details::asConst( m_children ) )
            arg->checkCorrectnessBeforeParsing( flags, names );
    }
 
    void checkCorrectnessAfterParsing() const override
    {
        for( const auto & arg : details::asConst( m_children ) )
            arg->checkCorrectnessAfterParsing();
 
        if( isRequired() && !isDefined() )
            throw BaseException(
                String( SL( "Not defined required argument \"" ) ) +
                name() + SL( "\"" ) );
    }
 
    void setCmdLine( CmdLine * cmdLine ) override
    {
        ArgIface::setCmdLine( cmdLine );
 
        for( const auto & arg : details::asConst( m_children ) )
            arg->setCmdLine( cmdLine );
    }
 
    bool isMisspelledName(
        const String & name,
        StringList & possibleNames ) const override
    {
        bool ret = false;
 
        std::for_each( children().cbegin(), children().cend(),
            [ & ] ( const auto & ch )
            {
                if( ch->isMisspelledName( name, possibleNames ) )
                    ret = true;
            } );
 
        return ret;
    }
 
protected:
    Arguments m_children;
 
private:
    DISABLE_COPY( GroupIface )
 
    
    String m_name;
    bool m_required;
}; // class GroupIface
 
} /* namespace Args */
 
#endif // ARGS__GROUP_IFACE_HPP__INCLUDED