multi_arg.hpp

Go to the documentation of this file.

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

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

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

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

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

    const String &value() const override;
    MultiArg &setValue(const String &v) override;

    virtual const StringList &values() const;

    size_t count() const;

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

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

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

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

    void clear() override
    {
        setDefined(false);
 
        m_values.clear();
    }
 
protected:
    void process(
        Context &context) override;
 
private:
    DISABLE_COPY(MultiArg)
 
    
    StringList m_values;
    size_t m_count;
    StringList m_defaultValues;
}; // class MultiArg
 
//
// MultiArg
//
 
template<typename T>
MultiArg::MultiArg(Char flag,
                   T &&name,
                   bool isWithValue,
                   bool isRequired)
    : Arg(flag,
          std::forward<T>(name),
          isWithValue,
          isRequired)
    , m_count(0)
{
}
 
inline MultiArg::MultiArg(Char flag,
                          bool isWithValue,
                          bool isRequired)
    : Arg(flag,
          isWithValue,
          isRequired)
    , m_count(0)
{
}
 
template<typename T>
MultiArg::MultiArg(T &&name,
                   bool isWithValue,
                   bool isRequired)
    : Arg(std::forward<T>(name),
          isWithValue,
          isRequired)
    , m_count(0)
{
}
 
inline MultiArg::~MultiArg()
{
}
 
inline const String &MultiArg::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;
    }
}
 
inline MultiArg &MultiArg::setValue(const String &v)
{
    m_values.push_back(v);
    return *this;
}
 
inline const StringList &MultiArg::values() const
{
    if (!m_values.empty()) {
        return m_values;
    } else {
        return m_defaultValues;
    }
}
 
inline size_t MultiArg::count() const
{
    if (!isWithValue()) {
        return m_count;
    } else if (!m_values.empty()) {
        return m_values.size();
    } else {
        return m_defaultValues.size();
    }
}
 
inline void MultiArg::process(Context &context)
{
    if (isWithValue()) {
        setDefined(eatValues(context,
                             m_values,
                             String(SL("Argument \"")) + name() + SL("\" requires value that wasn't presented."),
                             cmdLine()));
    } else {
        setDefined(true);
 
        ++m_count;
    }
}
 
} /* namespace Args */
 
#endif // ARGS__MULTI_ARG_HPP__INCLUDED