Change BasicClassifier to be templated on character types

And rename it from BasicStringClassifier to BasicClassifier.

Author: trflynn89

build/win/libfly/libfly.vcxproj

@@ -228,12 +228,12 @@
     <ClInclude Include="..\..\..\fly\types\numeric\detail\literal_parser.hpp" />
     <ClInclude Include="..\..\..\fly\types\numeric\endian.hpp" />
     <ClInclude Include="..\..\..\fly\types\numeric\literals.hpp" />
+    <ClInclude Include="..\..\..\fly\types\string\detail\classifier.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\format_context.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\format_parameters.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\format_specifier.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\format_string.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\stream_util.hpp" />
-    <ClInclude Include="..\..\..\fly\types\string\detail\string_classifier.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\string_converter.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\string_traits.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\detail\string_unicode.hpp" />

build/win/libfly/libfly.vcxproj.filters

@@ -289,6 +289,9 @@
     <ClInclude Include="..\..\..\fly\types\string\string_formatters.hpp">
       <Filter>types\string</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\..\fly\types\string\detail\classifier.hpp">
+      <Filter>types\string\detail</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\..\fly\types\string\detail\format_context.hpp">
       <Filter>types\string\detail</Filter>
     </ClInclude>
@@ -304,9 +307,6 @@
     <ClInclude Include="..\..\..\fly\types\string\detail\stream_util.hpp">
       <Filter>types\string\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\..\fly\types\string\detail\string_classifier.hpp">
-      <Filter>types\string\detail</Filter>
-    </ClInclude>
     <ClInclude Include="..\..\..\fly\types\string\detail\string_converter.hpp">
       <Filter>types\string\detail</Filter>
     </ClInclude>

build/win/libfly_unit_tests/libfly_unit_tests.vcxproj

@@ -255,11 +255,11 @@
     <ClCompile Include="..\..\..\test\types\json\json_traits.cpp" />
     <ClCompile Include="..\..\..\test\types\numeric\endian.cpp" />
     <ClCompile Include="..\..\..\test\types\numeric\literals.cpp" />
+    <ClCompile Include="..\..\..\test\types\string\classifier.cpp" />
     <ClCompile Include="..\..\..\test\types\string\format_parameters.cpp" />
     <ClCompile Include="..\..\..\test\types\string\format_string.cpp" />
     <ClCompile Include="..\..\..\test\types\string\lexer.cpp" />
     <ClCompile Include="..\..\..\test\types\string\string.cpp" />
-    <ClCompile Include="..\..\..\test\types\string\string_classifier.cpp" />
     <ClCompile Include="..\..\..\test\types\string\string_converter.cpp" />
     <ClCompile Include="..\..\..\test\types\string\string_format.cpp" />
     <ClCompile Include="..\..\..\test\types\string\string_traits.cpp" />

build/win/libfly_unit_tests/libfly_unit_tests.vcxproj.filters

@@ -158,6 +158,9 @@
     <ClCompile Include="..\..\..\test\types\numeric\literals.cpp">
       <Filter>types\numeric</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\..\test\types\string\classifier.cpp">
+      <Filter>types\string</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\..\test\types\string\format_parameters.cpp">
       <Filter>types\string</Filter>
     </ClCompile>
@@ -170,9 +173,6 @@
     <ClCompile Include="..\..\..\test\types\string\string.cpp">
       <Filter>types\string</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\..\test\types\string\string_classifier.cpp">
-      <Filter>types\string</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\..\test\types\string\string_converter.cpp">
       <Filter>types\string</Filter>
     </ClCompile>

fly/types/string/detail/string_classifier.hpp fly/types/string/detail/classifier.hpp

@@ -14,12 +14,13 @@ namespace fly::detail {
  * @author Timothy Flynn ([email protected])
  * @version January 3, 2021
  */
-template <typename StringType>
-class BasicStringClassifier
+template <typename CharType>
+class BasicClassifier
 {
-    using traits = detail::BasicStringTraits<StringType>;
+    using string_type = std::basic_string<CharType>;
+
+    using traits = detail::BasicStringTraits<string_type>;
     using size_type = typename traits::size_type;
-    using char_type = typename traits::char_type;
     using view_type = typename traits::view_type;
     using int_type = typename traits::int_type;
 
@@ -45,7 +46,7 @@ class BasicStringClassifier
      * @return The length of the character array.
      */
     template <std::size_t N>
-    static constexpr size_type size(const char_type (&value)[N]);
+    static constexpr size_type size(const CharType (&value)[N]);
 
     /**
      * Checks if the given character is an alphabetic character as classified by the default C
@@ -59,7 +60,7 @@ class BasicStringClassifier
      *
      * @return True if the character is an alphabetic character.
      */
-    static constexpr bool is_alpha(char_type ch);
+    static constexpr bool is_alpha(CharType ch);
 
     /**
      * Checks if the given character is an upper-case alphabetic character as classified by the
@@ -73,7 +74,7 @@ class BasicStringClassifier
      *
      * @return True if the character is an alphabetic character.
      */
-    static constexpr bool is_upper(char_type ch);
+    static constexpr bool is_upper(CharType ch);
 
     /**
      * Checks if the given character is a lower-case alphabetic character as classified by the
@@ -87,7 +88,7 @@ class BasicStringClassifier
      *
      * @return True if the character is an alphabetic character.
      */
-    static constexpr bool is_lower(char_type ch);
+    static constexpr bool is_lower(CharType ch);
 
     /**
      * Converts the given character to an upper-case alphabetic character as classified by the
@@ -101,7 +102,7 @@ class BasicStringClassifier
      *
      * @return The converted character.
      */
-    static constexpr char_type to_upper(char_type ch);
+    static constexpr CharType to_upper(CharType ch);
 
     /**
      * Converts the given character to a lower-case alphabetic character as classified by the
@@ -115,7 +116,7 @@ class BasicStringClassifier
      *
      * @return The converted character.
      */
-    static constexpr char_type to_lower(char_type ch);
+    static constexpr CharType to_lower(CharType ch);
 
     /**
      * Checks if the given character is a decimal digit character.
@@ -128,7 +129,7 @@ class BasicStringClassifier
      *
      * @return True if the character is a decimal digit character.
      */
-    static constexpr bool is_digit(char_type ch);
+    static constexpr bool is_digit(CharType ch);
 
     /**
      * Checks if the given character is a hexadecimal digit character.
@@ -141,7 +142,7 @@ class BasicStringClassifier
      *
      * @return True if the character is a hexadecimal digit character.
      */
-    static constexpr bool is_x_digit(char_type ch);
+    static constexpr bool is_x_digit(CharType ch);
 
     /**
      * Checks if the given character is a whitespace character as classified by the default C
@@ -155,7 +156,7 @@ class BasicStringClassifier
      *
      * @return True if the character is a whitespace character.
      */
-    static constexpr bool is_space(char_type ch);
+    static constexpr bool is_space(CharType ch);
 
 private:
     /**
@@ -166,125 +167,125 @@ class BasicStringClassifier
      *
      * @return The modified character.
      */
-    static constexpr char_type unify_az_characters(char_type ch);
-
-    static constexpr const auto s_null_terminator = FLY_CHR(char_type, '\0');
-    static constexpr const auto s_zero = FLY_CHR(char_type, '0');
-    static constexpr const auto s_upper_a = FLY_CHR(char_type, 'A');
-    static constexpr const auto s_upper_z = FLY_CHR(char_type, 'Z');
-    static constexpr const auto s_upper_f = FLY_CHR(char_type, 'F');
-    static constexpr const auto s_lower_a = FLY_CHR(char_type, 'a');
-    static constexpr const auto s_lower_z = FLY_CHR(char_type, 'z');
-    static constexpr const auto s_space = FLY_CHR(char_type, ' ');
-    static constexpr const auto s_form_feed = FLY_CHR(char_type, '\f');
-    static constexpr const auto s_line_feed = FLY_CHR(char_type, '\n');
-    static constexpr const auto s_carriage_return = FLY_CHR(char_type, '\r');
-    static constexpr const auto s_horizontal_tab = FLY_CHR(char_type, '\t');
-    static constexpr const auto s_vertical_tab = FLY_CHR(char_type, '\v');
+    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 <typename StringType>
+template <typename CharType>
 template <typename T, enable_if<detail::is_like_supported_string<T>>>
-constexpr inline auto BasicStringClassifier<StringType>::size(T &&value) -> size_type
+constexpr inline auto BasicClassifier<CharType>::size(T &&value) -> size_type
 {
-    if constexpr (any_same_v<T, StringType, view_type>)
+    using U = std::remove_cvref_t<T>;
+
+    if constexpr (std::is_array_v<U> || std::is_pointer_v<U>)
     {
-        return value.size();
+        return std::char_traits<CharType>::length(std::forward<T>(value));
     }
     else
     {
-        return std::char_traits<char_type>::length(std::forward<T>(value));
+        return value.size();
     }
 }
 
 //==================================================================================================
-template <typename StringType>
+template <typename CharType>
 template <std::size_t N>
-constexpr inline auto BasicStringClassifier<StringType>::size(const char_type (&value)[N])
-    -> size_type
+constexpr inline 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 <typename StringType>
-constexpr inline bool BasicStringClassifier<StringType>::is_alpha(char_type ch)
+template <typename CharType>
+constexpr inline bool BasicClassifier<CharType>::is_alpha(CharType ch)
 {
     return is_upper(unify_az_characters(ch));
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr inline bool BasicStringClassifier<StringType>::is_upper(char_type ch)
+template <typename CharType>
+constexpr inline bool BasicClassifier<CharType>::is_upper(CharType ch)
 {
     return (ch >= s_upper_a) && (ch <= s_upper_z);
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr inline bool BasicStringClassifier<StringType>::is_lower(char_type ch)
+template <typename CharType>
+constexpr inline bool BasicClassifier<CharType>::is_lower(CharType ch)
 {
     return (ch >= s_lower_a) && (ch <= s_lower_z);
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr inline auto BasicStringClassifier<StringType>::to_upper(char_type ch) -> char_type
+template <typename CharType>
+constexpr inline CharType BasicClassifier<CharType>::to_upper(CharType ch)
 {
     if (is_lower(ch))
     {
-        ch = static_cast<char_type>(static_cast<int_type>(ch) & s_case_mask);
+        ch = static_cast<CharType>(static_cast<int_type>(ch) & s_case_mask);
     }
 
     return ch;
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr inline auto BasicStringClassifier<StringType>::to_lower(char_type ch) -> char_type
+template <typename CharType>
+constexpr inline CharType BasicClassifier<CharType>::to_lower(CharType ch)
 {
     if (is_upper(ch))
     {
-        ch = static_cast<char_type>(static_cast<int_type>(ch) | s_case_bit);
+        ch = static_cast<CharType>(static_cast<int_type>(ch) | s_case_bit);
     }
 
     return ch;
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr inline bool BasicStringClassifier<StringType>::is_digit(char_type ch)
+template <typename CharType>
+constexpr inline bool BasicClassifier<CharType>::is_digit(CharType ch)
 {
     return (ch ^ s_zero) < 10;
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr inline bool BasicStringClassifier<StringType>::is_x_digit(char_type ch)
+template <typename CharType>
+constexpr inline 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 <typename StringType>
-constexpr inline bool BasicStringClassifier<StringType>::is_space(char_type ch)
+template <typename CharType>
+constexpr inline 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 <typename StringType>
-constexpr inline auto BasicStringClassifier<StringType>::unify_az_characters(char_type ch)
-    -> char_type
+template <typename CharType>
+constexpr inline CharType BasicClassifier<CharType>::unify_az_characters(CharType ch)
 {
-    return static_cast<char_type>(static_cast<int_type>(ch) & s_case_mask);
+    return static_cast<CharType>(static_cast<int_type>(ch) & s_case_mask);
 }
 
 } // namespace fly::detail

fly/types/string/detail/format_parameters.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "fly/types/string/detail/string_classifier.hpp"
+#include "fly/types/string/detail/classifier.hpp"
 #include "fly/types/string/detail/string_traits.hpp"
 #include "fly/types/string/string_formatters.hpp"
 
@@ -367,7 +367,7 @@ constexpr inline BasicFormatParameter<FormatContext>::BasicFormatParameter(const
 
     if constexpr (std::is_array_v<U> || std::is_pointer_v<U>)
     {
-        view = view_type(value, fly::detail::BasicStringClassifier<string_type>::size(value));
+        view = view_type(value, BasicClassifier<char_type>::size(value));
     }
     else
     {

fly/types/string/detail/format_specifier.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "fly/types/string/detail/string_classifier.hpp"
+#include "fly/types/string/detail/classifier.hpp"
 #include "fly/types/string/lexer.hpp"
 #include "fly/types/string/literals.hpp"
 
@@ -587,16 +587,14 @@ constexpr void BasicFormatSpecifier<CharType>::parse_type(
     FormatString &format,
     typename FormatString::ParameterType parameter_type)
 {
-    using classifier = BasicStringClassifier<std::basic_string<CharType>>;
-
     if (auto ch = format.m_lexer.peek(); ch)
     {
         if (auto type = type_of(ch.value()); type)
         {
             m_type = type.value();
             format.m_lexer.consume();
 
-            if (classifier::is_upper(ch.value()))
+            if (BasicClassifier<CharType>::is_upper(ch.value()))
             {
                 m_case = Case::Upper;
             }

fly/types/string/lexer.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "fly/types/string/detail/string_classifier.hpp"
+#include "fly/types/string/detail/classifier.hpp"
 #include "fly/types/string/detail/string_traits.hpp"
 #include "fly/types/string/literals.hpp"
 
@@ -31,7 +31,7 @@ class BasicLexer
     using string_type = std::basic_string<CharType>;
 
     using traits = detail::BasicStringTraits<string_type>;
-    using classifier = detail::BasicStringClassifier<string_type>;
+    using classifier = detail::BasicClassifier<CharType>;
     using view_type = typename traits::view_type;
 
 public: