argument_name.hpp

Go to the documentation of this file.

// Copyright (c) 2023-2026 Jakub Musiał
// This file is part of the CPP-ARGON project (https://github.com/SpectraL519/cpp-argon).
// 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 argon {
 
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 argon