groups.hpp

Go to the documentation of this file.

 
/*
    SPDX-FileCopyrightText: 2026 Igor Mironchik <igor.mironchik@gmail.com>
    SPDX-License-Identifier: MIT
*/

 
#ifndef ARGS__GROUPS_HPP__INCLUDED
#define ARGS__GROUPS_HPP__INCLUDED
 
// Args include.
#include "group_iface.hpp"
#include "types.hpp"
 
// C++ include.
#include <algorithm>
 
namespace Args
{
 
//
// OnlyOneGroup
//

class OnlyOneGroup final : public GroupIface
{
public:
    template<typename T>
    explicit OnlyOneGroup(T &&name,
                          bool required = false)
        : GroupIface(std::forward<T>(name),
                     required)
    {
    }
 
    virtual ~OnlyOneGroup()
    {
    }

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

    bool isDefined() const override
    {
        return std::any_of(children().cbegin(), children().cend(), [](const auto &arg) {
            return arg->isDefined();
        });
    }
 
protected:
    void checkCorrectnessBeforeParsing(
        StringList &flags,
        StringList &names) const override
    {
        GroupIface::checkCorrectnessBeforeParsing(flags, names);
 
        for (const auto &arg : details::asConst(children())) {
            if (arg->isRequired()) {
                throw BaseException(String(SL("Required argument \""))
                                    + arg->name()
                                    + SL("\" is not allowed to be in OnlyOne group \"")
                                    + name()
                                    + SL("\"."));
            }
        }
    }

    void checkCorrectnessAfterParsing() const override
    {
        GroupIface::checkCorrectnessAfterParsing();
 
        ArgIface *defined = nullptr;
 
        for (const auto &arg : details::asConst(children())) {
            if (arg->isDefined()) {
                if (defined) {
                    throw BaseException(String(SL("Only one argument can "
                                                  "be defined in OnlyOne group \""))
                                        + name()
                                        + SL("\". ")
                                        + SL("Whereas defined \"")
                                        + defined->name()
                                        + SL("\" and \"")
                                        + arg->name()
                                        + SL("\"."));
                } else {
                    defined = arg.get();
                }
            }
        }
    }
}; // class OnlyOneGroup
 
//
// AllOfGroup
//

class AllOfGroup final : public GroupIface
{
public:
    template<typename T>
    explicit AllOfGroup(T &&name,
                        bool required = false)
        : GroupIface(std::forward<T>(name),
                     required)
    {
    }
 
    virtual ~AllOfGroup()
    {
    }

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

    bool isDefined() const override
    {
        return !std::any_of(children().cbegin(), children().cend(), [](const auto &arg) {
            return !arg->isDefined();
        });
    }
 
protected:
    void checkCorrectnessBeforeParsing(
        StringList &flags,
        StringList &names) const override
    {
        GroupIface::checkCorrectnessBeforeParsing(flags, names);
 
        for (const auto &arg : details::asConst(children())) {
            if (arg->isRequired()) {
                throw BaseException(String(SL("Required argument \""))
                                    + arg->name()
                                    + SL("\" is not allowed to ")
                                    + SL("be in AllOf group \"")
                                    + name()
                                    + SL("\"."));
            }
        }
    }

    void checkCorrectnessAfterParsing() const override
    {
        GroupIface::checkCorrectnessAfterParsing();
 
        const bool defined = std::any_of(children().cbegin(), children().cend(), [](const auto &arg) {
            return arg->isDefined();
        });
 
        const bool all = std::all_of(children().cbegin(), children().cend(), [](const auto &arg) {
            return arg->isDefined();
        });
 
        if (defined && !all) {
            throw BaseException(String(SL("All arguments in "
                                          "AllOf group \""))
                                + name()
                                + SL("\" should be defined."));
        }
    }
}; // class AllOfGroup
 
//
// AtLeastOneGroup
//

class AtLeastOneGroup final : public GroupIface
{
public:
    template<typename T>
    explicit AtLeastOneGroup(T &&name,
                             bool required = false)
        : GroupIface(std::forward<T>(name),
                     required)
    {
    }
 
    virtual ~AtLeastOneGroup()
    {
    }

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

    bool isDefined() const override
    {
        return std::any_of(children().cbegin(), children().cend(), [](const auto &arg) {
            return arg->isDefined();
        });
    }
 
protected:
    void checkCorrectnessBeforeParsing(
        StringList &flags,
        StringList &names) const override
    {
        GroupIface::checkCorrectnessBeforeParsing(flags, names);
 
        for (const auto &arg : details::asConst(children())) {
            if (arg->isRequired()) {
                throw BaseException(String(SL("Required argument \""))
                                    + arg->name()
                                    + SL("\" is not allowed to ")
                                    + SL("be in AtLeastOne group \"")
                                    + name()
                                    + SL("\"."));
            }
        }
    }
}; // class AtLeastOneGroup
 
} /* namespace Args */
 
#endif // ARGS__GROUPS_HPP__INCLUDED