argument_name.hpp

Go to the documentation of this file.

// Copyright (c) 2023-2025 Jakub Musiał
// This file is part of the CPP-AP project (https://github.com/SpectraL519/cpp-ap).
// Licensed under the MIT License. See the LICENSE file in the project root for full license information.
 
 
#pragma once
 
#include <cstdint>
#include <format>
#include <optional>
#include <string>
#include <string_view>
 
namespace ap {
 
namespace detail {
 
struct argument_name {
    enum class match_type : std::uint8_t {
        m_any, 
        m_primary, 
        m_secondary 
    };
    using enum match_type;
 
    argument_name() = delete;
 
    argument_name& operator=(const argument_name&) = delete;
    argument_name& operator=(argument_name&&) = delete;
 
    argument_name(const argument_name&) = default;
    argument_name(argument_name&&) = default;
 
    argument_name(
        std::optional<std::string> primary,
        std::optional<std::string> secondary = std::nullopt,
        std::optional<char> flag_char = std::nullopt
    )
    : primary(std::move(primary)),
      secondary(std::move(secondary)),
      flag_char(std::move(flag_char)) {
        if (not (this->primary or this->secondary))
            throw std::logic_error("An argument name cannot be empty! At least one of "
                                   "primary/secondary must be specified");
    }
 
    ~argument_name() = default;
 
    bool operator==(const argument_name& other) const noexcept {
        return this->primary == other.primary and this->secondary == other.secondary;
    }
 
    [[nodiscard]] bool match(std::string_view arg_name, const match_type m_type = m_any)
        const noexcept {
        switch (m_type) {
        case m_any:
            return this->primary == arg_name or this->secondary == arg_name;
        case m_primary:
            return this->primary == arg_name;
        case m_secondary:
            return this->secondary == arg_name;
        }
 
        return false;
    }
 
    [[nodiscard]] bool match(
        const argument_name& arg_name, [[maybe_unused]] const match_type m_type = m_any
    ) const noexcept {
        if (arg_name.primary and this->match(arg_name.primary.value()))
            return true;
 
        if (arg_name.secondary)
            return this->match(arg_name.secondary.value());
 
        return false;
    }
 
    [[nodiscard]] std::string str() const noexcept {
        // if flag_char = nullopt, then the fallback character doesn't matter - the string will be empty
        const std::string fc(this->flag_char.has_value(), this->flag_char.value_or(char()));
 
        std::string primary_str =
            this->primary ? std::format("{}{}{}", fc, fc, this->primary.value()) : "";
        std::string separator = this->primary and this->secondary ? ", " : "";
        std::string secondary_str =
            this->secondary ? std::format("{}{}", fc, this->secondary.value()) : "";
 
        return std::format("{}{}{}", primary_str, separator, secondary_str);
    }
 
    friend std::ostream& operator<<(std::ostream& os, const argument_name& arg_name) noexcept {
        os << arg_name.str();
        return os;
    }
 
    const std::optional<std::string> primary; 
    const std::optional<std::string> secondary; 
    const std::optional<char> flag_char; 
};
 
enum class argument_name_discriminator : bool {
    n_primary, 
    n_secondary 
};
 
} // namespace detail
 
using enum detail::argument_name_discriminator;
 
} // namespace ap