command.hpp

Go to the documentation of this file.

 
/*
    SPDX-FileCopyrightText: 2026 Igor Mironchik <igor.mironchik@gmail.com>
    SPDX-License-Identifier: MIT
*/
 
#ifndef ARGS__COMMAND_HPP__INCLUDED
#define ARGS__COMMAND_HPP__INCLUDED
 
// Args include.
#include "api.hpp"
#include "context.hpp"
#include "enums.hpp"
#include "group_iface.hpp"
#include "types.hpp"
#include "utils.hpp"
#include "value_utils.hpp"
 
namespace Args
{
 
//
// Command
//

class Command : public GroupIface
{
    friend class CmdLine;
    friend class HelpPrinter;
    friend class Help;
 
public:
    template<typename T>
    explicit Command(T &&nm,
                     ValueOptions opt = ValueOptions::NoValue,
                     bool isSubCommandRequired = false)
        : GroupIface(std::forward<T>(nm))
        , m_opt(opt)
        , m_isDefined(false)
        , m_isSubCommandRequired(isSubCommandRequired)
        , m_subCommand(nullptr)
    {
        if (details::isArgument(name()) || details::isFlag(name())) {
            throw BaseException(String(SL("Command's name can't "
                                          "start with \"-\" whereas you are trying to set name to \""))
                                + name()
                                + SL("\"."));
        }
 
        if (name().empty()) {
            throw BaseException(String(SL("Command can't be with empty name.")));
        }
 
        switch (m_opt) {
        case ValueOptions::OneValue: {
            m_valueSpecifier = SL("arg");
        } break;
 
        case ValueOptions::ManyValues: {
            m_valueSpecifier = SL("args");
        } break;
 
        default:
            break;
        }
    }
 
    virtual ~Command()
    {
    }

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

    bool isDefined() const override
    {
        return m_isDefined;
    }

    bool isWithValue() const override
    {
        return (m_opt == ValueOptions::OneValue || m_opt == ValueOptions::ManyValues);
    }

    Command &setRequired(bool on = true) override
    {
        UNUSED(on)
        return *this;
    }

    const String &valueSpecifier() const override
    {
        return m_valueSpecifier;
    }

    Command &setValueSpecifier(const String &vs)
    {
        m_valueSpecifier = vs;
        return *this;
    }

    const String &description() const override
    {
        return m_description;
    }

    Command &setDescription(const String &desc)
    {
        m_description = desc;
        return *this;
    }

    const String &longDescription() const override
    {
        if (!m_longDescription.empty()) {
            return m_longDescription;
        } else {
            return m_description;
        }
    }

    Command &setLongDescription(const String &desc)
    {
        m_longDescription = desc;
        return *this;
    }

    const String &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;
        }
    }

    const StringList &values() const
    {
        if (!m_values.empty()) {
            return m_values;
        } else {
            return m_defaultValues;
        }
    }

    const String &defaultValue() const override
    {
        if (!m_defaultValues.empty()) {
            return m_defaultValues.front();
        } else {
            return details::DummyString<>::c_string;
        }
    }

    Command &setDefaultValue(const String &v)
    {
        m_defaultValues.push_back(v);
        return *this;
    }

    const StringList &defaultValues() const
    {
        return m_defaultValues;
    }

    Command &setDefaultValues(const StringList &v)
    {
        m_defaultValues = v;
        return *this;
    }

    bool isMisspelledName(
        const String &nm,
        StringList &possibleNames) const override
    {
        bool ret = false;
 
        if (details::isMisspelledName(nm, name())) {
            possibleNames.push_back(name());
 
            ret = true;
        }
 
        if (GroupIface::isMisspelledName(nm, possibleNames)) {
            return true;
        } else {
            return ret;
        }
    }

    bool isMisspelledCommand(
        const String &nm,
        StringList &possibleNames) const
    {
        if (details::isMisspelledName(nm, name())) {
            possibleNames.push_back(name());
 
            return true;
        } else {
            return false;
        }
    }

    void clear() override
    {
        m_isDefined = false;
 
        m_values.clear();
 
        GroupIface::clear();
    }
 
    using GroupIface::addArg;

    Command &addArg(ArgPtr arg) override
    {
        if (arg->type() == ArgType::Command && m_opt != ValueOptions::NoValue) {
            throw BaseException(
                String(SL("Addition of commands to command with "
                          "value is disallowed.")));
        }
 
        if (std::find(m_children.cbegin(), m_children.cend(), arg) == m_children.cend()) {
            if (cmdLine()) {
                arg->setCmdLine(cmdLine());
            }
 
            m_children.push_back(std::move(arg));
        }
        return *this;
    }
 
protected:
    ArgIface *findArgument(
        const String &n) override
    {
        if (name() == n) {
            return this;
        } else {
            return nullptr;
        }
    }

    ArgIface *findChild(
        const String &name)
    {
        auto *arg = GroupIface::findArgument(name);
 
        if (!arg && m_subCommand) {
            return m_subCommand->findChild(name);
        }
 
        return arg;
    }

    void process(
        Context &ctx) override
    {
        m_isDefined = true;
 
        switch (m_opt) {
        case ValueOptions::ManyValues: {
            eatValues(ctx,
                      m_values,
                      String(SL("Command \"")) + name() + SL("\" requires value that wasn't presented."),
                      cmdLine());
        } break;
 
        case ValueOptions::OneValue: {
            m_values.push_back(
                eatOneValue(ctx,
                            String(SL("Command \"")) + name() + SL("\" requires value that wasn't presented."),
                            cmdLine()));
        } break;
 
        default:
            break;
        }
    }

    void checkCorrectnessBeforeParsing(
        StringList &flags,
        StringList &names) const override
    {
        if (details::isCorrectName(name())) {
            auto it = std::find(names.begin(), names.end(), name());
 
            if (it != names.end()) {
                throw BaseException(String(SL("Redefinition of command "
                                              "with name \""))
                                    + name()
                                    + SL("\"."));
            } else {
                names.push_back(name());
            }
        } else {
            throw BaseException(String(SL("Disallowed name \"")) + name() + SL("\" for the command."));
        }
 
        StringList ftmp = flags;
        StringList ntmp = names;
 
        GroupIface::checkCorrectnessBeforeParsing(ftmp, ntmp);
    }

    void checkCorrectnessAfterParsing() const override
    {
        if (isDefined()) {
            GroupIface::checkCorrectnessAfterParsing();
        }
 
        if (isDefined() && m_isSubCommandRequired && !m_subCommand) {
            throw BaseException(String(SL("Wasn't defined required sub-command of command \"")) + name() + SL("\"."));
        }
    }

    void setCurrentSubCommand(Command *sub)
    {
        m_subCommand = sub;
    }
 
private:
    DISABLE_COPY(Command)
 
    
    ValueOptions m_opt;
    String m_valueSpecifier;
    String m_description;
    String m_longDescription;
    bool m_isDefined;
    bool m_isSubCommandRequired;
    StringList m_values;
    StringList m_defaultValues;
    Command *m_subCommand;
}; // class Command
 
} /* namespace Args */
 
#endif // ARGS__COMMAND_HPP__INCLUDED