ArgumentConstraint.hpp

Go to the documentation of this file.

#pragma once

#include <algorithm> // find
#include <memory>    // unique_ptr

namespace TAP {

enum class ConstraintType {
    None,   
    One,    
    Any,    
    All,    
};

template<ConstraintType CType>
class ArgumentConstraint: public BaseArgument {
protected:
    std::vector< std::unique_ptr<BaseArgument> > m_args;

    std::string m_usageString;

public:
    template<typename ... A>
    ArgumentConstraint(A&& ... args);

    ArgumentConstraint(const ArgumentConstraint& other) :
        BaseArgument(other), m_usageString(other.m_usageString) {
        for(auto const & arg: other.m_args) {
            m_args.emplace_back(std::move(arg->clone()));
        }
    }

    ArgumentConstraint(ArgumentConstraint&&) = default;

    virtual ~ArgumentConstraint() {
    }

    ArgumentConstraint& operator=(ArgumentConstraint other) {
        std::swap(m_args, other.m_args);
        std::swap(m_usageString, other.m_usageString);
        return *this;
    }

    ArgumentConstraint& operator=(ArgumentConstraint&&) = default;

    ArgumentConstraint& operator+=(Argument& arg) {
        add(arg);
        return *this;
    }

    size_t size() const {
        return m_args.size();
    }

    void find_all_arguments(std::vector<const Argument*>& collector) const override {
        for(const auto& arg: m_args) {
            arg->find_all_arguments(collector);
        }
    }

    void check_valid() const override;

    std::string usage() const override {
        return m_usageString;
    }

    std::unique_ptr<BaseArgument> clone() const & override {
        return std::unique_ptr<BaseArgument>(new ArgumentConstraint(*this));
    }

    std::unique_ptr<BaseArgument> clone() && override {
        return std::unique_ptr<BaseArgument>(new ArgumentConstraint(std::move(*this)));
    }

protected:
    template<typename Arg>
    ArgumentConstraint& add(Arg&& arg);

    unsigned int count() const override;

    void diagnose_args() const;

    std::string usageArgument(const Argument& arg) const;

    template<ConstraintType ACType>
    std::string usageArgument(const ArgumentConstraint<ACType>& arg) const;
};

class ArgumentSet : public ArgumentConstraint<ConstraintType::Any> {
protected:
    std::string m_name;

    mutable std::vector<const Argument*> m_args;

    bool m_updateArgs = true;
public:
    template<typename ... A>
    ArgumentSet(const std::string& name, A&& ... args);

    ArgumentSet(const ArgumentSet&) = default;

    ArgumentSet(ArgumentSet&&) = default;

    virtual ~ArgumentSet() {
    }

    ArgumentSet& operator=(const ArgumentSet&) = default;

    ArgumentSet& operator=(ArgumentSet&&) = default;

    const std::string& name() const {
        return m_name;
    }

    const std::vector<const Argument*>& args() const {
        if (m_updateArgs) {
            m_args.clear();
            find_all_arguments(m_args);
        }
        return m_args;
    }

    template<typename Arg>
    ArgumentSet& add(Arg&& arg) {
        ArgumentConstraint<ConstraintType::Any>::add(std::forward<Arg>(arg));
        m_updateArgs = true;
        return *this;
    }

    std::unique_ptr<BaseArgument> clone() const & override {
        return std::unique_ptr<BaseArgument>(new ArgumentSet(*this));
    }

    std::unique_ptr<BaseArgument> clone() && override {
        return std::unique_ptr<BaseArgument>(new ArgumentSet(std::move(*this)));
    }
};

}