Change BasicLexer to be templated on character types

And rename it from BasicStringLexer to BasicLexer.

Author: trflynn89

build/win/libfly/libfly.vcxproj

@@ -237,9 +237,9 @@
     <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" />
+    <ClInclude Include="..\..\..\fly\types\string\lexer.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\string.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\string_formatters.hpp" />
-    <ClInclude Include="..\..\..\fly\types\string\string_lexer.hpp" />
     <ClInclude Include="..\..\..\fly\types\string\string_literal.hpp" />
   </ItemGroup>
   <ItemGroup>

build/win/libfly/libfly.vcxproj.filters

@@ -277,13 +277,13 @@
     <ClInclude Include="..\..\..\fly\types\numeric\detail\literal_parser.hpp">
       <Filter>types\numeric\detail</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\..\fly\types\string\string.hpp">
+    <ClInclude Include="..\..\..\fly\types\string\lexer.hpp">
       <Filter>types\string</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\..\fly\types\string\string_formatters.hpp">
+    <ClInclude Include="..\..\..\fly\types\string\string.hpp">
       <Filter>types\string</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\..\fly\types\string\string_lexer.hpp">
+    <ClInclude Include="..\..\..\fly\types\string\string_formatters.hpp">
       <Filter>types\string</Filter>
     </ClInclude>
     <ClInclude Include="..\..\..\fly\types\string\string_literal.hpp">

build/win/libfly_unit_tests/libfly_unit_tests.vcxproj

@@ -257,11 +257,11 @@
     <ClCompile Include="..\..\..\test\types\numeric\literals.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_lexer.cpp" />
     <ClCompile Include="..\..\..\test\types\string\string_traits.cpp" />
     <ClCompile Include="..\..\..\test\types\string\string_unicode.cpp" />
   </ItemGroup>

build/win/libfly_unit_tests/libfly_unit_tests.vcxproj.filters

@@ -164,6 +164,9 @@
     <ClCompile Include="..\..\..\test\types\string\format_string.cpp">
       <Filter>types\string</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\..\test\types\string\lexer.cpp">
+      <Filter>types\string</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\..\test\types\string\string.cpp">
       <Filter>types\string</Filter>
     </ClCompile>
@@ -176,9 +179,6 @@
     <ClCompile Include="..\..\..\test\types\string\string_format.cpp">
       <Filter>types\string</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\..\test\types\string\string_lexer.cpp">
-      <Filter>types\string</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\..\test\types\string\string_traits.cpp">
       <Filter>types\string</Filter>
     </ClCompile>

fly/net/endpoint.hpp

@@ -2,7 +2,7 @@
 
 #include "fly/fly.hpp"
 #include "fly/net/socket/socket_types.hpp"
-#include "fly/types/string/string_lexer.hpp"
+#include "fly/types/string/lexer.hpp"
 
 #include <compare>
 #include <limits>
@@ -216,7 +216,7 @@ Endpoint<IPAddressType>::from_string(std::string_view endpoint)
         }
     }
 
-    fly::BasicStringLexer<std::string> lexer(std::move(port_view));
+    fly::Lexer lexer(std::move(port_view));
 
     auto address = IPAddressType::from_string(std::move(address_view));
     auto port = lexer.consume_number();

fly/net/ipv4_address.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "fly/types/numeric/endian.hpp"
-#include "fly/types/string/string_lexer.hpp"
+#include "fly/types/string/lexer.hpp"
 
 #include <array>
 #include <compare>
@@ -156,7 +156,7 @@ constexpr std::optional<IPv4Address> IPv4Address::from_string(std::string_view a
     constexpr const auto s_max32 = static_cast<std::uint64_t>(std::numeric_limits<int_type>::max());
     constexpr const auto s_decimal = '.';
 
-    fly::BasicStringLexer<std::string> lexer(std::move(address));
+    fly::Lexer lexer(std::move(address));
 
     std::array<int_type, 4> parts {};
     std::size_t index = 0;

fly/net/ipv6_address.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "fly/fly.hpp"
-#include "fly/types/string/string_lexer.hpp"
+#include "fly/types/string/lexer.hpp"
 
 #include <algorithm>
 #include <array>
@@ -172,7 +172,7 @@ constexpr std::optional<IPv6Address> IPv6Address::from_string(std::string_view a
         static_cast<std::uint64_t>(std::numeric_limits<std::uint16_t>::max());
     constexpr const auto s_colon = ':';
 
-    fly::BasicStringLexer<std::string> lexer(std::move(address));
+    fly::Lexer lexer(std::move(address));
     address_type parts {};
 
     std::optional<std::size_t> index_after_short_form;

fly/types/string/detail/format_specifier.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "fly/types/string/detail/string_classifier.hpp"
-#include "fly/types/string/string_lexer.hpp"
+#include "fly/types/string/lexer.hpp"
 #include "fly/types/string/string_literal.hpp"
 
 #include <array>

fly/types/string/detail/format_string.hpp

@@ -3,7 +3,7 @@
 #include "fly/fly.hpp"
 #include "fly/types/string/detail/format_specifier.hpp"
 #include "fly/types/string/detail/string_traits.hpp"
-#include "fly/types/string/string_lexer.hpp"
+#include "fly/types/string/lexer.hpp"
 #include "fly/types/string/string_literal.hpp"
 
 #include <array>
@@ -31,8 +31,8 @@ template <typename StringType, typename... ParameterTypes>
 class BasicFormatString
 {
     using traits = BasicStringTraits<StringType>;
-    using lexer = fly::BasicStringLexer<StringType>;
     using char_type = typename traits::char_type;
+    using lexer = fly::BasicLexer<char_type>;
     using view_type = typename traits::view_type;
 
     using FormatSpecifier = BasicFormatSpecifier<char_type>;

fly/types/string/string_lexer.hpp fly/types/string/lexer.hpp

@@ -9,19 +9,29 @@
 
 namespace fly {
 
+template <typename CharType>
+class BasicLexer;
+
+using Lexer = BasicLexer<char>;
+using WLexer = BasicLexer<wchar_t>;
+using Lexer8 = BasicLexer<char8_t>;
+using Lexer16 = BasicLexer<char16_t>;
+using Lexer32 = BasicLexer<char32_t>;
+
 /**
  * Helper class to perform lexical analysis of a C-string literal. All methods are constant
  * expressions, allowing for string analysis at compile time.
  *
  * @author Timothy Flynn ([email protected])
  * @version January 3, 2021
  */
-template <typename StringType>
-class BasicStringLexer
+template <typename CharType>
+class BasicLexer
 {
-    using traits = detail::BasicStringTraits<StringType>;
-    using classifier = detail::BasicStringClassifier<StringType>;
-    using char_type = typename traits::char_type;
+    using string_type = std::basic_string<CharType>;
+
+    using traits = detail::BasicStringTraits<string_type>;
+    using classifier = detail::BasicStringClassifier<string_type>;
     using view_type = typename traits::view_type;
 
 public:
@@ -33,14 +43,14 @@ class BasicStringLexer
      * @param literals Reference to a C-string literal of size N.
      */
     template <std::size_t N>
-    constexpr explicit BasicStringLexer(const char_type (&literals)[N]) noexcept;
+    constexpr explicit BasicLexer(const CharType (&literals)[N]) noexcept;
 
     /**
      * Constructor. Stores an existing view into a string.
      *
      * @param view The existing view into the string.
      */
-    constexpr explicit BasicStringLexer(view_type view) noexcept;
+    constexpr explicit BasicLexer(view_type view) noexcept;
 
     /**
      * @return A string view into the C-string literal.
@@ -61,15 +71,15 @@ class BasicStringLexer
      * @return If available, the character at the provided offset. Otherwise, an uninitialized
      *         value.
      */
-    constexpr std::optional<char_type> peek(std::size_t offset = 0);
+    constexpr std::optional<CharType> peek(std::size_t offset = 0);
 
     /**
      * If a character is available at the current position in the C-string literal, return that
      * character and advance the current position to the next character.
      *
      * @return If available, the current character. Otherwise, an uninitialized value.
      */
-    constexpr std::optional<char_type> consume();
+    constexpr std::optional<CharType> consume();
 
     /**
      * If a character is available at the current position in the C-string literal, and if that
@@ -80,7 +90,7 @@ class BasicStringLexer
      *
      * @return Whether the current character was available and matched the provided character.
      */
-    constexpr bool consume_if(char_type ch);
+    constexpr bool consume_if(CharType ch);
 
     /**
      * Beginning with the current position, retrieve characters from the C-string literal and
@@ -113,13 +123,13 @@ class BasicStringLexer
      * @return Whether the current character was available and satisfied the provided condition.
      */
     template <typename Condition>
-    constexpr std::optional<char_type> consume_if(Condition condition);
+    constexpr std::optional<CharType> consume_if(Condition condition);
 
-    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_f = FLY_CHR(char_type, 'F');
-    static constexpr const auto s_lower_a = FLY_CHR(char_type, 'a');
-    static constexpr const auto s_lower_f = FLY_CHR(char_type, 'f');
+    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_f = FLY_CHR(CharType, 'F');
+    static constexpr const auto s_lower_a = FLY_CHR(CharType, 'a');
+    static constexpr const auto s_lower_f = FLY_CHR(CharType, 'f');
 
     const std::size_t m_size;
     const view_type m_view;
@@ -128,39 +138,39 @@ class BasicStringLexer
 };
 
 //==================================================================================================
-template <typename StringType>
+template <typename CharType>
 template <std::size_t N>
-constexpr BasicStringLexer<StringType>::BasicStringLexer(const char_type (&literals)[N]) noexcept :
+constexpr BasicLexer<CharType>::BasicLexer(const CharType (&literals)[N]) noexcept :
     m_size(classifier::size(literals)),
     m_view(literals, m_size)
 {
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr BasicStringLexer<StringType>::BasicStringLexer(view_type view) noexcept :
+template <typename CharType>
+constexpr BasicLexer<CharType>::BasicLexer(view_type view) noexcept :
     m_size(view.size()),
     m_view(std::move(view))
 {
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr auto BasicStringLexer<StringType>::view() const -> view_type
+template <typename CharType>
+constexpr auto BasicLexer<CharType>::view() const -> view_type
 {
     return m_view;
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr std::size_t BasicStringLexer<StringType>::position() const
+template <typename CharType>
+constexpr std::size_t BasicLexer<CharType>::position() const
 {
     return m_index;
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr auto BasicStringLexer<StringType>::peek(std::size_t offset) -> std::optional<char_type>
+template <typename CharType>
+constexpr std::optional<CharType> BasicLexer<CharType>::peek(std::size_t offset)
 {
     if ((m_index + offset) >= m_size)
     {
@@ -171,8 +181,8 @@ constexpr auto BasicStringLexer<StringType>::peek(std::size_t offset) -> std::op
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr auto BasicStringLexer<StringType>::consume() -> std::optional<char_type>
+template <typename CharType>
+constexpr std::optional<CharType> BasicLexer<CharType>::consume()
 {
     if (m_index >= m_size)
     {
@@ -183,8 +193,8 @@ constexpr auto BasicStringLexer<StringType>::consume() -> std::optional<char_typ
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr bool BasicStringLexer<StringType>::consume_if(char_type ch)
+template <typename CharType>
+constexpr bool BasicLexer<CharType>::consume_if(CharType ch)
 {
     if (auto next = peek(); next && (next.value() == ch))
     {
@@ -196,8 +206,8 @@ constexpr bool BasicStringLexer<StringType>::consume_if(char_type ch)
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr std::optional<std::uintmax_t> BasicStringLexer<StringType>::consume_number()
+template <typename CharType>
+constexpr std::optional<std::uintmax_t> BasicLexer<CharType>::consume_number()
 {
     bool parsed_number = false;
     std::uintmax_t number = 0;
@@ -214,8 +224,8 @@ constexpr std::optional<std::uintmax_t> BasicStringLexer<StringType>::consume_nu
 }
 
 //==================================================================================================
-template <typename StringType>
-constexpr std::optional<std::uintmax_t> BasicStringLexer<StringType>::consume_hex_number()
+template <typename CharType>
+constexpr std::optional<std::uintmax_t> BasicLexer<CharType>::consume_hex_number()
 {
     bool parsed_number = false;
     std::uintmax_t number = 0;
@@ -243,10 +253,9 @@ constexpr std::optional<std::uintmax_t> BasicStringLexer<StringType>::consume_he
 }
 
 //==================================================================================================
-template <typename StringType>
+template <typename CharType>
 template <typename Condition>
-constexpr auto BasicStringLexer<StringType>::consume_if(Condition condition)
-    -> std::optional<char_type>
+constexpr std::optional<CharType> BasicLexer<CharType>::consume_if(Condition condition)
 {
     if (auto next = peek(); next && condition(next.value()))
     {

test/types/string/string_lexer.cpp test/types/string/lexer.cpp

@@ -1,4 +1,4 @@
-#include "fly/types/string/string_lexer.hpp"
+#include "fly/types/string/lexer.hpp"
 
 #include "fly/types/string/string_literal.hpp"
 
@@ -7,18 +7,10 @@
 
 #include <string>
 
-CATCH_TEMPLATE_TEST_CASE(
-    "BasicStringLexer",
-    "[string]",
-    std::string,
-    std::wstring,
-    std::u8string,
-    std::u16string,
-    std::u32string)
+CATCH_TEMPLATE_TEST_CASE("BasicLexer", "[string]", char, wchar_t, char8_t, char16_t, char32_t)
 {
-    using StringType = TestType;
-    using char_type = typename StringType::value_type;
-    using Lexer = fly::BasicStringLexer<StringType>;
+    using char_type = TestType;
+    using Lexer = fly::BasicLexer<char_type>;
 
     CATCH_SECTION("Cannot consume from empty lexer")
     {