arg.hpp

Go to the documentation of this file.

 
/*
    SPDX-FileCopyrightText: 2026 Igor Mironchik <igor.mironchik@gmail.com>
    SPDX-License-Identifier: MIT
*/
 
#ifndef ARGS__ARG_HPP__INCLUDED
#define ARGS__ARG_HPP__INCLUDED
 
// Args include.
#include "arg_iface.hpp"
#include "context.hpp"
#include "exceptions.hpp"
#include "types.hpp"
#include "utils.hpp"
#include "value_utils.hpp"
 
// C++ include.
#include <algorithm>
 
namespace Args
{
 
//
// Arg
//

class Arg : public ArgIface
{
public:
    template<typename T>
    Arg(
        Char flag,
        T &&name,
        bool isWithValue = false,
        bool isRequired = false);

    explicit Arg(
        Char flag,
        bool isWithValue = false,
        bool isRequired = false);

    template<typename T>
    explicit Arg(
        T &&name,
        bool isWithValue = false,
        bool isRequired = false);
 
    virtual ~Arg();

    ArgType type() const override
    {
        return ArgType::Arg;
    }

    String name() const override;

    bool isWithValue() const override;
    Arg &setWithValue(bool on = true);

    bool isRequired() const override;
    Arg &setRequired(bool on = true);

    bool isDefined() const override;
    Arg &setDefined(bool on = true);

    virtual const String &value() const;
    virtual Arg &setValue(const String &v);

    const String &flag() const override;
    Arg &setFlag(Char f);

    const String &argumentName() const override;
    Arg &setArgumentName(const String &name);

    const String &valueSpecifier() const override;
    Arg &setValueSpecifier(const String &vs);

    const String &description() const override;
    Arg &setDescription(const String &desc);

    const String &longDescription() const override;
    Arg &setLongDescription(const String &desc);

    const String &defaultValue() const override
    {
        return m_defaultValue;
    }

    virtual Arg &setDefaultValue(const String &v)
    {
        m_defaultValue = v;
        return *this;
    }

    bool isMisspelledName(
        const String &name,
        StringList &possibleNames) const override
    {
        if (!argumentName().empty()) {
            if (details::isMisspelledName(name, String(SL("--")) + argumentName())) {
                possibleNames.push_back(String(SL("--")) + argumentName());
 
                return true;
            }
        }
 
        return false;
    }

    void clear() override
    {
        setDefined(false);
 
        m_value.clear();
    }
 
protected:
    ArgIface *findArgument(
        const String &name) override
    {
        if (details::isArgument(name) && name.substr(2) == m_name) {
            return this;
        } else if (details::isFlag(name) && name.substr(1) == m_flag) {
            return this;
        } else {
            return nullptr;
        }
    }

    void process(
        Context &context) override;

    void checkCorrectnessBeforeParsing(
        StringList &flags,
        StringList &names) const override;

    void checkCorrectnessAfterParsing() const override;
 
private:
    DISABLE_COPY(Arg)
 
    
    bool m_isWithValue;
    bool m_isRequired;
    bool m_isDefined;
    String m_value;
    String m_flag;
    String m_name;
    String m_valueSpecifier;
    String m_description;
    String m_longDescription;
    String m_defaultValue;
}; // class Arg
 
//
// Arg
//
 
template<typename T>
Arg::Arg(Char flag,
         T &&name,
         bool isWithValue,
         bool isRequired)
    : m_isWithValue(isWithValue)
    , m_isRequired(isRequired)
    , m_isDefined(false)
    , m_flag(1,
             flag)
    , m_name(std::forward<T>(name))
    , m_valueSpecifier(SL("arg"))
{
}
 
inline Arg::Arg(Char flag,
                bool isWithValue,
                bool isRequired)
    : m_isWithValue(isWithValue)
    , m_isRequired(isRequired)
    , m_isDefined(false)
    , m_flag(1,
             flag)
    , m_valueSpecifier(SL("arg"))
{
}
 
template<typename T>
Arg::Arg(T &&name,
         bool isWithValue,
         bool isRequired)
    : m_isWithValue(isWithValue)
    , m_isRequired(isRequired)
    , m_isDefined(false)
    , m_name(std::forward<T>(name))
    , m_valueSpecifier(SL("arg"))
{
}
 
inline Arg::~Arg()
{
}
 
inline void Arg::process(Context &context)
{
    if (!isDefined()) {
        if (!isWithValue()) {
            setDefined(true);
        } else {
            setValue(eatOneValue(context,
                                 String(SL("Argument \"")) + name() + SL("\" requires value that wasn't presented."),
                                 cmdLine()));
 
            setDefined(true);
        }
    } else {
        throw BaseException(String(SL("Argument \"")) + name() + SL("\" already defined."));
    }
}
 
inline String Arg::name() const
{
    if (!m_name.empty()) {
        return SL("--") + m_name;
    } else {
        return SL("-") + m_flag;
    }
}
 
inline void Arg::checkCorrectnessBeforeParsing(StringList &flags,
                                               StringList &names) const
{
    if (!m_flag.empty()) {
        if (details::isCorrectFlag(m_flag)) {
            const String flag = String(SL("-")) + m_flag;
 
            auto it = std::find(flags.begin(), flags.end(), flag);
 
            if (it != flags.end()) {
                throw BaseException(String(SL("Redefinition of argument "
                                              "with flag \""))
                                    + flag
                                    + SL("\"."));
            } else {
                flags.push_back(flag);
            }
        } else {
            throw BaseException(String(SL("Disallowed flag \"-")) + m_flag + SL("\"."));
        }
    }
 
    if (!m_name.empty()) {
        if (details::isCorrectName(m_name)) {
            const String name = String(SL("--")) + m_name;
 
            auto it = std::find(names.begin(), names.end(), name);
 
            if (it != names.end()) {
                throw BaseException(String(SL("Redefinition of argument "
                                              "with name \""))
                                    + name
                                    + SL("\"."));
            } else {
                names.push_back(name);
            }
        } else {
            throw BaseException(String(SL("Disallowed name \"--")) + m_name + SL("\"."));
        }
    }
 
    if (m_flag.empty() && m_name.empty()) {
        throw BaseException(
            String(SL("Arguments with empty flag and name "
                      "are disallowed.")));
    }
}
 
inline void Arg::checkCorrectnessAfterParsing() const
{
    if (isRequired() && !isDefined()) {
        throw BaseException(String(SL("Undefined required argument \"")) + name() + SL("\"."));
    }
}
 
inline bool Arg::isWithValue() const
{
    return m_isWithValue;
}
 
inline Arg &Arg::setWithValue(bool on)
{
    m_isWithValue = on;
    return *this;
}
 
inline bool Arg::isRequired() const
{
    return m_isRequired;
}
 
inline Arg &Arg::setRequired(bool on)
{
    m_isRequired = on;
    return *this;
}
 
inline bool Arg::isDefined() const
{
    return m_isDefined;
}
 
inline Arg &Arg::setDefined(bool on)
{
    m_isDefined = on;
    return *this;
}
 
inline const String &Arg::value() const
{
    if (!m_value.empty()) {
        return m_value;
    } else {
        return m_defaultValue;
    }
}
 
inline Arg &Arg::setValue(const String &v)
{
    m_value = v;
    return *this;
}
 
inline const String &Arg::flag() const
{
    return m_flag;
}
 
inline Arg &Arg::setFlag(Char f)
{
    m_flag = String(1, f);
    return *this;
}
 
inline const String &Arg::argumentName() const
{
    return m_name;
}
 
inline Arg &Arg::setArgumentName(const String &name)
{
    m_name = name;
    return *this;
}
 
inline const String &Arg::valueSpecifier() const
{
    return m_valueSpecifier;
}
 
inline Arg &Arg::setValueSpecifier(const String &vs)
{
    m_valueSpecifier = vs;
    return *this;
}
 
inline const String &Arg::description() const
{
    return m_description;
}
 
inline Arg &Arg::setDescription(const String &desc)
{
    m_description = desc;
    return *this;
}
 
inline const String &Arg::longDescription() const
{
    if (!m_longDescription.empty()) {
        return m_longDescription;
    } else {
        return m_description;
    }
}
 
inline Arg &Arg::setLongDescription(const String &desc)
{
    m_longDescription = desc;
    return *this;
}
 
} /* namespace Args */
 
#endif // ARGS__ARG_HPP__INCLUDED