classifier.hpp

#pragma once
 
#include "fly/types/string/concepts.hpp"
#include "fly/types/string/detail/traits.hpp"
#include "fly/types/string/literals.hpp"
 
#include <string>
 
namespace fly::detail {
 
template <fly::StandardCharacter CharType>
class BasicClassifier
{
    using traits = detail::BasicStringTraits<CharType>;
    using size_type = typename traits::size_type;
    using view_type = typename traits::view_type;
    using int_type = typename traits::int_type;
 
public:
    template <fly::StandardStringLike T>
    static constexpr size_type size(T &&value);
 
    template <std::size_t N>
    static constexpr size_type size(const CharType (&value)[N]);
 
    static constexpr bool is_alpha(CharType ch);
 
    static constexpr bool is_upper(CharType ch);
 
    static constexpr bool is_lower(CharType ch);
 
    static constexpr CharType to_upper(CharType ch);
 
    static constexpr CharType to_lower(CharType ch);
 
    static constexpr bool is_digit(CharType ch);
 
    static constexpr bool is_x_digit(CharType ch);
 
    static constexpr bool is_space(CharType ch);
 
private:
    static constexpr CharType unify_az_characters(CharType ch);
 
    static constexpr const auto s_null_terminator = FLY_CHR(CharType, '\0');
    static constexpr const auto s_zero = FLY_CHR(CharType, '0');
    static constexpr const auto s_upper_a = FLY_CHR(CharType, 'A');
    static constexpr const auto s_upper_z = FLY_CHR(CharType, 'Z');
    static constexpr const auto s_upper_f = FLY_CHR(CharType, 'F');
    static constexpr const auto s_lower_a = FLY_CHR(CharType, 'a');
    static constexpr const auto s_lower_z = FLY_CHR(CharType, 'z');
    static constexpr const auto s_space = FLY_CHR(CharType, ' ');
    static constexpr const auto s_form_feed = FLY_CHR(CharType, '\f');
    static constexpr const auto s_line_feed = FLY_CHR(CharType, '\n');
    static constexpr const auto s_carriage_return = FLY_CHR(CharType, '\r');
    static constexpr const auto s_horizontal_tab = FLY_CHR(CharType, '\t');
    static constexpr const auto s_vertical_tab = FLY_CHR(CharType, '\v');
 
    static constexpr const auto s_case_bit = static_cast<int_type>(0x20);
    static constexpr const auto s_case_mask = static_cast<int_type>(~s_case_bit);
};
 
//==================================================================================================
template <fly::StandardCharacter CharType>
template <fly::StandardStringLike T>
constexpr auto BasicClassifier<CharType>::size(T &&value) -> size_type
{
    using U = std::remove_cvref_t<T>;
 
    if constexpr (std::is_array_v<U> || std::is_pointer_v<U>)
    {
        return std::char_traits<CharType>::length(std::forward<T>(value));
    }
    else
    {
        return value.size();
    }
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
template <std::size_t N>
constexpr auto BasicClassifier<CharType>::size(const CharType (&value)[N]) -> size_type
{
    static_assert(N > 0, "Character arrays must have non-zero size");
    return N - ((value[N - 1] == s_null_terminator) ? 1 : 0);
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr bool BasicClassifier<CharType>::is_alpha(CharType ch)
{
    return is_upper(unify_az_characters(ch));
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr bool BasicClassifier<CharType>::is_upper(CharType ch)
{
    return (ch >= s_upper_a) && (ch <= s_upper_z);
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr bool BasicClassifier<CharType>::is_lower(CharType ch)
{
    return (ch >= s_lower_a) && (ch <= s_lower_z);
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr CharType BasicClassifier<CharType>::to_upper(CharType ch)
{
    if (is_lower(ch))
    {
        ch = static_cast<CharType>(static_cast<int_type>(ch) & s_case_mask);
    }
 
    return ch;
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr CharType BasicClassifier<CharType>::to_lower(CharType ch)
{
    if (is_upper(ch))
    {
        ch = static_cast<CharType>(static_cast<int_type>(ch) | s_case_bit);
    }
 
    return ch;
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr bool BasicClassifier<CharType>::is_digit(CharType ch)
{
    return (ch ^ s_zero) < 10;
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr bool BasicClassifier<CharType>::is_x_digit(CharType ch)
{
    const auto alpha = unify_az_characters(ch);
    return is_digit(ch) || ((alpha >= s_upper_a) && (alpha <= s_upper_f));
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr bool BasicClassifier<CharType>::is_space(CharType ch)
{
    return (ch == s_space) || (ch == s_form_feed) || (ch == s_line_feed) ||
        (ch == s_carriage_return) || (ch == s_horizontal_tab) || (ch == s_vertical_tab);
}
 
//==================================================================================================
template <fly::StandardCharacter CharType>
constexpr CharType BasicClassifier<CharType>::unify_az_characters(CharType ch)
{
    return static_cast<CharType>(static_cast<int_type>(ch) & s_case_mask);
}
 
} // namespace fly::detail