Argument.hpp

Go to the documentation of this file.

#pragma once

#include <functional>
#include <memory>

namespace TAP {

class Argument;

using ArgumentCheckFunc = std::function<void(const Argument&)>;

class Argument: public BaseArgument {
protected:
    std::string m_flags;
    std::vector<std::string> m_names;

    bool m_isPositional;

    std::string m_description;

    unsigned int m_min = 1;
    unsigned int m_max = 1;

    mutable std::shared_ptr<unsigned int> m_count;

    ArgumentCheckFunc m_checkFunc = nullptr;

#ifndef TAP_AUTOFLAG

    Argument(std::string description) :
            m_isPositional(true), m_description(std::move(description)), m_count(std::make_shared<unsigned int>(0)) {
    }
#endif

public:
    // Creation/definition
#ifdef TAP_AUTOFLAG

    Argument(std::string description) :
            m_isPositional(true), m_description(std::move(description)), m_count(std::make_shared<unsigned int>(0)) {

        parse_description();
        // Cannot perform below check as it requires virtual calls
        // instead, user will have to make sure this does not happen
        /*if (!takes_value() && m_isPositional) {
            throw std::logic_error("Cannot create positional argument without value");
        }*/
    }
#endif

    Argument(std::string description, char flag) :
            m_isPositional(false), m_description(std::move(description)), m_count(std::make_shared<unsigned int>(0)) {
#ifdef TAP_AUTOFLAG
        parse_description();
#endif
        alias(flag);
    }

    Argument(std::string description, std::string name) :
            m_isPositional(false), m_description(std::move(description)), m_count(std::make_shared<unsigned int>(0)) {
#ifdef TAP_AUTOFLAG
        parse_description();
#endif
        alias(std::move(name));
    }

    Argument(std::string description, char flag, std::string name) :
            m_isPositional(false), m_description(std::move(description)), m_count(std::make_shared<unsigned int>(0)) {
#ifdef TAP_AUTOFLAG
        parse_description();
#endif
        alias(flag, std::move(name));
    }

    Argument(const Argument&) = default;

    Argument(Argument&&) = default;

    virtual ~Argument() {
    }

    Argument& operator=(const Argument& other) = default;

    Argument& operator=(Argument&& other) = default;

    Argument& alias(char flag) {
        m_flags.insert(m_flags.end(), flag);
        return *this;
    }

    Argument& alias(std::string name) {
        m_names.push_back(std::move(name));
        return *this;
    }

    Argument& alias(char flag, std::string name) {
        m_flags.insert(m_flags.end(), flag);
        m_names.push_back(std::move(name));
        return *this;
    }

    const std::string& description() const {
        return m_description;
    }

    virtual Argument& check(ArgumentCheckFunc checkFunc) {
        m_checkFunc = checkFunc;
        return *this;
    }

    // Lookup operations

    bool matches() const {
        if (m_isPositional) {
            return true;
        }
        return false;
    }

    bool matches(char flag) const {
        for (char self_flag : m_flags) {
            if (self_flag == flag) {
                return true;
            }
        }
        return false;
    }

    bool matches(const std::string& name) const {
        for (const std::string& self_name : m_names) {
            if (self_name == name) {
                return true;
            }
        }
        return false;
    }

    void find_all_arguments(std::vector<const Argument*>& collector) const override {
        collector.push_back(this);
    }

    // Make public
    using BaseArgument::set_required;
    using BaseArgument::required;

    // Count operations

    Argument& many(bool many = true) {
        if (!many) {
            // Note: max of N (!=0) does not mean many
            m_max = std::max(m_max, 1u);
        } else {
            m_max = 0u;
        }
        return *this;
    }

    /*bool many() const {
        return m_max != 1;
    }*/

    Argument& min(unsigned int min) {
        if (min == 0) {
            throw std::logic_error("Cannot set zero minimum");
        }
        m_min = min;
        if (min > m_max && m_max != 0u) {
            m_max = m_min;
        }
        return *this;
    }

    unsigned int min() const {
        return m_min;
    }

    Argument& max(unsigned int max) {
        m_max = max;
        return *this;
    }

    unsigned int max() const {
        return m_max;
    }

    // value operations

    unsigned int count() const override {
        return *m_count;
    }

    bool can_set() const {
        return (m_max == 0 || *m_count < m_max);
    }

    virtual void set() const {
        (*m_count)++;
        check();
    }

    virtual bool takes_value() const {
        // Note: not the same as setCount < max, it is a fixed property
        return false;
    }

    // Validation operations

    void check_valid() const override;

    std::string usage() const override;

    virtual std::string ident() const;

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

    std::unique_ptr<BaseArgument> clone() && override {
        return std::unique_ptr<BaseArgument>(new Argument(std::move(*this)));
    }
protected:
    virtual void check() const {
        if (m_checkFunc != nullptr) {
            m_checkFunc(*this);
        }
    }

private:
#ifdef TAP_AUTOFLAG

    void parse_description() {
        bool escape = false;
        bool addFlag = false;
        bool addName = false;
        auto nameStart = m_description.begin();
        std::vector<std::string::iterator> specialChars;
        for (auto it = m_description.begin(); it != m_description.end(); ++it) {
            char c = *it;
            bool skip = false;

            if (addFlag) {
                alias(c);
                addFlag = false;
                m_isPositional = false;
                skip = true;
            }

            if (!isalnum(c) && addName) {
                // Check if valid character for a name
                if (it != nameStart) {
                    alias( std::string(nameStart, it) );
                    m_isPositional = false;
                }
                addName = false;
            }

            if (skip) {
                continue;
            }

            switch(c) {
                case '\\':
                    escape = !escape;
                    if (!escape) {
                        specialChars.push_back(it);
                    }
                    break;
                case '%':
                    // Treat next word as flag
                    if (escape) {
                        escape = false;
                        specialChars.push_back(it-1);
                        continue;
                    } else {
                        addFlag = true;
                        specialChars.push_back(it);
                    }
                    break;
                case '$':
                    // Treat next word as name
                    if (escape) {
                        escape = false;
                        specialChars.push_back(it-1);
                        continue;
                    } else {
                        addName = true;
                        nameStart = it+1;
                        specialChars.push_back(it);
                    }
                    break;
                case '&':
                    // Treat next word as flag and name
                    if (escape) {
                        escape = false;
                        specialChars.push_back(it-1);
                        continue;
                    } else {
                        addFlag = true;
                        addName = true;
                        nameStart = it+1;
                        specialChars.push_back(it);
                    }
                    break;
                default:
                    break;
            }
        }
        if (addName && nameStart != m_description.end()) {
            alias(std::string(nameStart, m_description.end()));
        }
        // Remove the special characters
        for (auto it = specialChars.rbegin(); it != specialChars.rend(); it++) {
            m_description.erase(*it, (*it)+1);
        }
    }
#endif
};

class ValueAcceptor {
protected:
    ~ValueAcceptor() {}
public:
    virtual void set(const std::string& value) const = 0;
};

}