format_parse_context.hpp

#pragma once
 
#include "fly/types/string/concepts.hpp"
#include "fly/types/string/detail/format_parameter_type.hpp"
#include "fly/types/string/detail/traits.hpp"
#include "fly/types/string/lexer.hpp"
 
#include <cstddef>
#include <string_view>
 
namespace fly::detail {
 
template <fly::StandardCharacter CharType>
class BasicFormatParseContext
{
    using traits = BasicStringTraits<CharType>;
    using view_type = typename traits::view_type;
 
public:
    template <std::size_t N>
    constexpr explicit BasicFormatParseContext(
        const CharType (&format)[N],
        const ParameterType *parameters,
        std::size_t parameters_size) noexcept;
 
    constexpr std::size_t next_position();
 
    constexpr std::optional<ParameterType> parameter_type(std::size_t position);
 
    constexpr fly::BasicLexer<CharType> &lexer();
 
    constexpr view_type view() const;
 
    void on_error(const char *error);
 
    constexpr bool has_error() const;
 
    std::string error() const;
 
private:
    BasicFormatParseContext(BasicFormatParseContext &&) = delete;
    BasicFormatParseContext &operator=(BasicFormatParseContext &&) = delete;
 
    BasicFormatParseContext(const BasicFormatParseContext &) = delete;
    BasicFormatParseContext &operator=(const BasicFormatParseContext &) = delete;
 
    fly::BasicLexer<CharType> m_lexer;
 
    const ParameterType *m_parameters;
    std::size_t m_parameters_size;
 
    std::size_t m_next_position {0};
    bool m_expect_no_positions_specified {false};
    bool m_expect_all_positions_specified {false};
 
    std::string_view m_error;
};
 
//==================================================================================================
template <fly::StandardCharacter CharType>
template <std::size_t N>
constexpr BasicFormatParseContext<CharType>::BasicFormatParseContext(
    const CharType (&format)[N],
    const ParameterType *parameters,
    std::size_t parameters_size) noexcept :
    m_lexer(format),
    m_parameters(parameters),
    m_parameters_size(parameters_size)
{
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr std::size_t BasicFormatParseContext<CharType>::next_position()
{
    std::size_t position = 0;
 
    if (auto specified_position = m_lexer.consume_number(); specified_position)
    {
        m_expect_all_positions_specified = true;
        position = static_cast<std::size_t>(*specified_position);
    }
    else
    {
        m_expect_no_positions_specified = true;
        position = m_next_position++;
    }
 
    if (m_expect_all_positions_specified && m_expect_no_positions_specified)
    {
        on_error("Argument position must be provided on all or not on any specifier");
    }
 
    return position;
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr std::optional<ParameterType>
BasicFormatParseContext<CharType>::parameter_type(std::size_t position)
{
    if (position >= m_parameters_size)
    {
        on_error("Argument position exceeds number of provided arguments");
        return std::nullopt;
    }
 
    return m_parameters[position];
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr fly::BasicLexer<CharType> &BasicFormatParseContext<CharType>::lexer()
{
    return m_lexer;
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr auto BasicFormatParseContext<CharType>::view() const -> view_type
{
    return m_lexer.view();
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
void BasicFormatParseContext<CharType>::on_error(const char *error)
{
    m_error = error;
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr bool BasicFormatParseContext<CharType>::has_error() const
{
    return !m_error.empty();
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
std::string BasicFormatParseContext<CharType>::error() const
{
    return std::string(m_error.data(), m_error.size());
}
 
} // namespace fly::detail