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 <format>
#include <optional>
#include <string>
#include <string_view>
 
namespace ap::detail {
 
struct argument_name {
    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::string_view primary) : primary(primary) {}
 
    argument_name(std::string_view primary, std::string_view secondary)
    : primary(primary), secondary(secondary) {}
 
    ~argument_name() = default;
 
    bool operator==(const argument_name& other) const noexcept {
        if (not (this->secondary and other.secondary) and (this->secondary or other.secondary))
            return false;
 
        if (this->primary != other.primary)
            return false;
 
        return this->secondary ? this->secondary.value() == other.secondary.value() : true;
    }
 
    [[nodiscard]] bool match(std::string_view arg_name) const noexcept {
        return arg_name == this->primary
            or (this->secondary and arg_name == this->secondary.value());
    }
 
    [[nodiscard]] bool match(const argument_name& arg_name) const noexcept {
        if (this->match(arg_name.primary))
            return true;
 
        if (arg_name.secondary)
            return this->match(arg_name.secondary.value());
 
        return false;
    }
 
    [[nodiscard]] std::string str(const std::optional<char> flag_char = std::nullopt)
        const noexcept {
        // if flag_char = nullopt, then the fallback character doesn't matter - the string will be empty
        const std::string fc(flag_char.has_value(), flag_char.value_or(char()));
        return this->secondary
                 ? std::format("{}{}{}, {}{}", fc, fc, this->primary, fc, this->secondary.value())
                 : std::format("{}{}{}", fc, fc, this->primary);
    }
 
    friend std::ostream& operator<<(std::ostream& os, const argument_name& arg_name) noexcept {
        os << arg_name.str();
        return os;
    }
 
    const std::string primary; 
    const std::optional<std::string> secondary; 
};
 
} // namespace ap::detail