group_iface.hpp

Go to the documentation of this file.

 
/*
    SPDX-FileCopyrightText: 2026 Igor Mironchik <igor.mironchik@gmail.com>
    SPDX-License-Identifier: MIT
*/
 
#ifndef ARGS__GROUP_IFACE_HPP__INCLUDED
#define ARGS__GROUP_IFACE_HPP__INCLUDED
 
// Args include.
#include "arg_iface.hpp"
#include "exceptions.hpp"
#include "types.hpp"
#include "utils.hpp"
 
// C++ include.
#include <algorithm>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace Args
{
 
class Command;
 
//
// GroupIface
//

class GroupIface : public ArgIface
{
public:
    using ArgPtr = std::unique_ptr<ArgIface, details::Deleter<ArgIface>>;
    using Arguments = std::vector<ArgPtr>;
 
    template<typename T>
    explicit GroupIface(T &&name,
                        bool required = false)
        : m_name(std::forward<T>(name))
        , m_required(required)
    {
    }
 
    virtual ~GroupIface()
    {
    }

    const Arguments &children() const
    {
        return m_children;
    }

    GroupIface &addArg(ArgIface &arg)
    {
        return addArg(ArgPtr(&arg, details::Deleter<ArgIface>(false)));
    }

    GroupIface &addArg(ArgIface *arg)
    {
        return addArg(ArgPtr(arg, details::Deleter<ArgIface>(false)));
    }

    virtual GroupIface &addArg(ArgPtr arg)
    {
        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;
    }

    String name() const override
    {
        return m_name;
    }

    bool isWithValue() const override
    {
        return false;
    }

    bool isRequired() const override
    {
        return m_required;
    }

    virtual GroupIface &setRequired(bool on = true)
    {
        m_required = on;
        return *this;
    }

    const String &flag() const override
    {
        return details::DummyString<>::c_string;
    }

    const String &argumentName() const override
    {
        return details::DummyString<>::c_string;
    }

    const String &valueSpecifier() const override
    {
        return details::DummyString<>::c_string;
    }

    const String &description() const override
    {
        return details::DummyString<>::c_string;
    }

    const String &longDescription() const override
    {
        return details::DummyString<>::c_string;
    }

    void clear() override
    {
        std::for_each(children().begin(), children().end(), [&](const auto &ch) {
            ch->clear();
        });
    }
 
protected:
    ArgIface *findArgument(
        const String &name) override
    {
        for (const auto &arg : details::asConst(m_children)) {
            ArgIface *tmp = arg->findArgument(name);
 
            if (tmp != nullptr) {
                return tmp;
            }
        }
 
        return nullptr;
    }

    void process(
        Context &) override
    {
    }

    void checkCorrectnessBeforeParsing(
        StringList &flags,
        StringList &names) const override
    {
        for (const auto &arg : details::asConst(m_children)) {
            arg->checkCorrectnessBeforeParsing(flags, names);
        }
    }

    void checkCorrectnessAfterParsing() const override
    {
        for (const auto &arg : details::asConst(m_children)) {
            arg->checkCorrectnessAfterParsing();
        }
 
        if (isRequired() && !isDefined()) {
            throw BaseException(String(SL("Not defined required argument \"")) + name() + SL("\""));
        }
    }

    void setCmdLine(CmdLine *cmdLine) override
    {
        ArgIface::setCmdLine(cmdLine);
 
        for (const auto &arg : details::asConst(m_children)) {
            arg->setCmdLine(cmdLine);
        }
    }

    bool isMisspelledName(
        const String &name,
        StringList &possibleNames) const override
    {
        bool ret = false;
 
        std::for_each(children().cbegin(), children().cend(), [&](const auto &ch) {
            if (ch->isMisspelledName(name, possibleNames))
                ret = true;
        });
 
        return ret;
    }
 
protected:
    Arguments m_children;
 
private:
    DISABLE_COPY(GroupIface)
 
    
    String m_name;
    bool m_required;
}; // class GroupIface
 
} /* namespace Args */
 
#endif // ARGS__GROUP_IFACE_HPP__INCLUDED