token_type.hpp

// Copyright (C) 2022-2023 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/traits.hpp"
#include "arg_router/utility/string_view_ops.hpp"
 
namespace arg_router::parsing
{
enum class prefix_type : std::uint8_t {
    long_,   
    short_,  
    none     
};
 
[[nodiscard]] constexpr std::string_view to_string(prefix_type prefix) noexcept
{
    switch (prefix) {
    case prefix_type::long_: return config::long_prefix;
    case prefix_type::short_: return config::short_prefix;
    default: return "";
    }
}
 
struct token_type {
    constexpr token_type(prefix_type p, std::string_view n) noexcept : prefix{p}, name{n} {}
 
    [[nodiscard]] constexpr bool operator==(const token_type& other) const noexcept
    {
        return prefix == other.prefix && name == other.name;
    }
 
    [[nodiscard]] constexpr bool operator!=(const token_type& other) const noexcept
    {
        return !(*this == other);
    }
 
    prefix_type prefix;     
    std::string_view name;  
};
 
[[nodiscard]] inline string to_string(const token_type& token)
{
    using namespace utility::string_view_ops;
    return to_string(token.prefix) + token.name;
}
 
[[nodiscard]] inline string to_string(const vector<token_type>& view)
{
    auto str = string{};
    for (auto i = 0u; i < view.size(); ++i) {
        str += to_string(view[i]);
        if (i != (view.size() - 1)) {
            str += ", ";
        }
    }
    return str;
}
 
[[nodiscard]] inline token_type get_token_type(std::string_view token)
{
    using namespace config;
 
    if (token.substr(0, long_prefix.size()) == long_prefix) {
        token.remove_prefix(long_prefix.size());
        return {prefix_type::long_, token};
    }
    if (token.substr(0, short_prefix.size()) == short_prefix) {
        token.remove_prefix(short_prefix.size());
        return {prefix_type::short_, token};
    }
    return {prefix_type::none, token};
}
 
template <typename Node>
[[nodiscard]] inline token_type get_token_type([[maybe_unused]] const Node& node,
                                               std::string_view token)
{
    using namespace config;
 
    if constexpr (traits::has_long_name_method_v<Node>) {
        if (token.substr(0, long_prefix.size()) == long_prefix) {
            token.remove_prefix(long_prefix.size());
            return {prefix_type::long_, token};
        }
    }
    if constexpr (traits::has_short_name_method_v<Node>) {
        if ((token.substr(0, short_prefix.size()) == short_prefix) &&
            (token.substr(0, long_prefix.size()) != long_prefix)) {
            token.remove_prefix(short_prefix.size());
            return {prefix_type::short_, token};
        }
    }
    return {prefix_type::none, token};
}
}  // namespace arg_router::parsing