multi_arg.hpp

Go to the documentation of this file.

 
#ifndef ARGS__MULTI_ARG_HPP__INCLUDED
#define ARGS__MULTI_ARG_HPP__INCLUDED
 
// Args include.
#include "arg.hpp"
#include "context.hpp"
#include "exceptions.hpp"
#include "value_utils.hpp"
#include "utils.hpp"
#include "types.hpp"
 
// C++ include.
#include <utility>
 
 
namespace Args {
 
//
// MultiArg
//
 
class MultiArg
    :   public Arg
{
public:
    template< typename T >
    MultiArg(
        Char flag,
        T && name,
        bool isWithValue = false,
        bool isRequired = false );
 
    explicit MultiArg(
        Char flag,
        bool isWithValue = false,
        bool isRequired = false );
 
    template< typename T >
    explicit MultiArg(
        T && name,
        bool isWithValue = false,
        bool isRequired = false );
 
    virtual ~MultiArg();
 
    ArgType type() const override
    {
        return ArgType::MultiArg;
    }
 
    const String & value() const override;
    void setValue( const String & v ) override;
 
    virtual const StringList & values() const;
 
    size_t count() const;
 
    const String & defaultValue() const override
    {
        if( !m_defaultValues.empty() )
            return m_defaultValues.front();
        else
            return details::DummyString<>::c_string;
    }
 
    void setDefaultValue( const String & v ) override
    {
        m_defaultValues.push_back( v );
    }
 
    const StringList & defaultValues() const
    {
        return m_defaultValues;
    }
 
    void setDefaultValues( const StringList & v )
    {
        m_defaultValues = v;
    }
 
    void clear() override
    {
        setDefined( false );
 
        m_values.clear();
    }
 
protected:
    void process(
        Context & context ) override;
 
private:
    DISABLE_COPY( MultiArg )
 
    
    StringList m_values;
    size_t m_count;
    StringList m_defaultValues;
}; // class MultiArg
 
 
//
// MultiArg
//
 
template< typename T >
MultiArg::MultiArg( Char flag, T && name,
    bool isWithValue, bool isRequired )
    :   Arg( flag, std::forward< T > ( name ), isWithValue, isRequired )
    ,   m_count( 0 )
{
}
 
inline
MultiArg::MultiArg( Char flag,
    bool isWithValue, bool isRequired )
    :   Arg( flag, isWithValue, isRequired )
    ,   m_count( 0 )
{
}
 
template< typename T >
MultiArg::MultiArg( T && name,
    bool isWithValue, bool isRequired )
    :   Arg( std::forward< T > ( name ), isWithValue, isRequired )
    ,   m_count( 0 )
{
}
 
inline
MultiArg::~MultiArg()
{
}
 
inline const String &
MultiArg::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;
}
 
inline void
MultiArg::setValue( const String & v )
{
    m_values.push_back( v );
}
 
inline const StringList &
MultiArg::values() const
{
    if( !m_values.empty() )
        return m_values;
    else
        return m_defaultValues;
}
 
inline size_t
MultiArg::count() const
{
    if( !isWithValue() )
        return m_count;
    else if( !m_values.empty() )
        return m_values.size();
    else
        return m_defaultValues.size();
}
 
inline void
MultiArg::process( Context & context )
{
    if( isWithValue() )
    {
        setDefined( eatValues( context, m_values,
            String( SL( "Argument \"" ) ) +
                name() + SL( "\" requires value that wasn't presented." ),
            cmdLine() ) );
    }
    else
    {
        setDefined( true );
 
        ++m_count;
    }
}
 
} /* namespace Args */
 
#endif // ARGS__MULTI_ARG_HPP__INCLUDED