groups.hpp

Go to the documentation of this file.

 
#ifndef ARGS__GROUPS_HPP__INCLUDED
#define ARGS__GROUPS_HPP__INCLUDED
 
// Args include.
#include "group_iface.hpp"
#include "types.hpp"
 
// C++ include.
#include <algorithm>
 
 
namespace Args {
 
//
// OnlyOneGroup
//
 
class OnlyOneGroup final
    :   public GroupIface
{
public:
    template< typename T >
    explicit OnlyOneGroup( T && name,
        bool required = false )
        :   GroupIface( std::forward< T > ( name ), required )
    {
    }
 
    virtual ~OnlyOneGroup()
    {
    }
 
    ArgType type() const override
    {
        return ArgType::OnlyOneGroup;
    }
 
    bool isDefined() const override
    {
        return std::any_of( children().cbegin(), children().cend(),
            [] ( const auto & arg ) { return arg->isDefined(); } );
    }
 
protected:
    void checkCorrectnessBeforeParsing(
        StringList & flags,
        StringList & names ) const override
    {
        GroupIface::checkCorrectnessBeforeParsing( flags, names );
 
        for( const auto & arg : details::asConst( children() ) )
        {
            if( arg->isRequired() )
                throw BaseException( String( SL( "Required argument \"" ) ) +
                    arg->name() +
                    SL( "\" is not allowed to be in OnlyOne group \"" ) +
                    name() + SL( "\"." ) );
        }
    }
 
    void checkCorrectnessAfterParsing() const override
    {
        GroupIface::checkCorrectnessAfterParsing();
 
        ArgIface * defined = nullptr;
 
        for( const auto & arg : details::asConst( children() ) )
        {
            if( arg->isDefined() )
            {
                if( defined )
                    throw BaseException( String( SL( "Only one argument can "
                        "be defined in OnlyOne group \"" ) ) + name() + SL( "\". " ) +
                        SL( "Whereas defined \"" ) + defined->name() +
                        SL( "\" and \"" ) + arg->name() + SL( "\"." ) );
                else
                    defined = arg.get();
            }
        }
    }
}; // class OnlyOneGroup
 
 
//
// AllOfGroup
//
 
class AllOfGroup final
    :   public GroupIface
{
public:
    template< typename T >
    explicit AllOfGroup( T && name,
        bool required = false )
        :   GroupIface( std::forward< T > ( name ), required )
    {
    }
 
    virtual ~AllOfGroup()
    {
    }
 
    ArgType type() const override
    {
        return ArgType::AllOfGroup;
    }
 
    bool isDefined() const override
    {
        return !std::any_of( children().cbegin(), children().cend(),
            [] ( const auto & arg ) { return !arg->isDefined(); } );
    }
 
protected:
    void checkCorrectnessBeforeParsing(
        StringList & flags,
        StringList & names ) const override
    {
        GroupIface::checkCorrectnessBeforeParsing( flags, names );
 
        for( const auto & arg : details::asConst( children() ) )
        {
            if( arg->isRequired() )
                throw BaseException( String( SL( "Required argument \"" ) ) +
                    arg->name() +
                    SL( "\" is not allowed to " ) +
                    SL( "be in AllOf group \"" ) + name() + SL( "\"." ) );
        }
    }
 
    void checkCorrectnessAfterParsing() const override
    {
        GroupIface::checkCorrectnessAfterParsing();
 
        const bool defined = std::any_of( children().cbegin(), children().cend(),
            [] ( const auto & arg ) { return arg->isDefined(); } );
 
        const bool all = std::all_of( children().cbegin(), children().cend(),
            [] ( const auto & arg ) { return arg->isDefined(); } );
 
        if( defined && !all )
            throw BaseException( String( SL( "All arguments in "
                "AllOf group \"" ) ) + name() + SL( "\" should be defined." ) );
    }
}; // class AllOfGroup
 
 
//
// AtLeastOneGroup
//
 
class AtLeastOneGroup final
    :   public GroupIface
{
public:
    template< typename T >
    explicit AtLeastOneGroup( T && name,
        bool required = false )
        :   GroupIface( std::forward< T > ( name ), required )
    {
    }
 
    virtual ~AtLeastOneGroup()
    {
    }
 
    ArgType type() const override
    {
        return ArgType::AtLeastOneGroup;
    }
 
    bool isDefined() const override
    {
        return std::any_of( children().cbegin(), children().cend(),
            [] ( const auto & arg ) { return arg->isDefined(); } );
    }
 
protected:
    void checkCorrectnessBeforeParsing(
        StringList & flags,
        StringList & names ) const override
    {
        GroupIface::checkCorrectnessBeforeParsing( flags, names );
 
        for( const auto & arg : details::asConst( children() ) )
        {
            if( arg->isRequired() )
                throw BaseException( String( SL( "Required argument \"" ) ) +
                    arg->name() +
                    SL( "\" is not allowed to " ) +
                    SL( "be in AtLeastOne group \"" ) + name() + SL( "\"." ) );
        }
    }
}; // class AtLeastOneGroup
 
} /* namespace Args */
 
#endif // ARGS__GROUPS_HPP__INCLUDED