Improve StringLiteral interface

Author: oblivioncth

lib/core/include/qx/core/qx-abstracterror.h

@@ -88,7 +88,7 @@ friend class Error;
 //-Class Variables----------------------------------------------------------------------------------------------------------
 public:
     static constexpr quint16 TYPE_CODE = ECode;
-    static constexpr QLatin1StringView TYPE_NAME{EName.value};
+    static constexpr QLatin1StringView TYPE_NAME{EName};
 
 private:
     static const bool REGISTER;

lib/utility/include/qx/utility/qx-stringliteral.h

@@ -1,35 +1,58 @@
 #ifndef QX_STRINGLITERAL_H
 #define QX_STRINGLITERAL_H
 
+// Standard Library Includes
 #include <algorithm>
+#include <concepts>
+
+// Qt Includes
+#include <QLatin1String>
 
 namespace Qx
 {
 
-template<size_t N>
-struct StringLiteral
+template<std::integral C, size_t N>
+class TStringLiteral
 {
-//-Instance Fields---------------------------------------------------------------------------------------------------
-    char value[N];
+//-Instance Variables---------------------------------------------------------------------------------------------------
+public:
+    C _str[N]; // Must be public due to C++20 limitations
 
 //-Constructor----------------------------------------------------------------------------------------------------------
-    constexpr StringLiteral(const char (&str)[N])
-    {
-        std::copy_n(str, N, value);
-    }
-};
+private:
+    constexpr TStringLiteral() = default;
 
-template <size_t N>
-struct StringLiteral16
-{
-    char16_t value[N];
+public:
+    constexpr TStringLiteral(const C (&str)[N]) { std::copy_n(str, N, _str); }
+
+//-Instance Functions----------------------------------------------------------------------------------------------------
+public:
+    const C* data() const { return _str; }
+    size_t size() const { return N - 1; }
 
-    constexpr StringLiteral16(const char16_t (&str)[N])
+//-Operators--------------------------------------------------------------------------------------------------------
+public:
+    constexpr std::strong_ordering operator<=>(const TStringLiteral& other) const = default;
+
+    template<size_t M>
+    constexpr auto operator+(const TStringLiteral<C, M>& other) const
     {
-        std::copy_n(str, N, value);
+        TStringLiteral<C, N + M - 1> res;
+        std::copy_n(this->_str, N - 1, res); // N chars
+        std::copy_n(other._str, M, res + (N - 1)); // M chars + '/0'
+        return res;
     }
+
+    constexpr operator QLatin1StringView() const requires std::same_as<C, char> { return QLatin1StringView(_str, N - 1); }
+    constexpr operator QStringView() const requires std::same_as<C, char16_t > { return QStringView(_str, N - 1); }
 };
 
+template<size_t N>
+using StringLiteral = TStringLiteral<char, N>;
+
+template<size_t N>
+using StringLiteral16 = TStringLiteral<char16_t, N>;
+
 }
 
 #endif // QX_STRINGLITERAL_H

lib/utility/src/qx-stringliteral.dox

@@ -5,27 +5,65 @@ namespace Qx
 //===============================================================================================================
 
 /*!
- *  @struct StringLiteral qx/utility/qx-stringliteral.h
+ *  @struct TStringLiteral qx/utility/qx-stringliteral.h
  *  @ingroup qx-utility
  *
- *  @brief The StringLiteral template struct acts as a literal class type wrapper around a C-style string
- *  that effectively allows the string to be used as a non-type template parameter.
+ *  @brief The TStringLiteral template class acts as a literal class type wrapper around a C-style string
+ *  that effectively allows the string to be used as a non-type template parameter. Generally you should
+ *  use the predefined aliases instead of the template directly.
  *
  *  @snippet qx-stringliteral.cpp 0
  */
 
-//-Instance Fields---------------------------------------------------------------------------------------------
+//-Constructor-------------------------------------------------------------------------------------------------
+//Public:
 /*!
- *  @var StringLiteral::value
+ * @fn TStringLiteral::TStringLiteral(const C (&str)[N])
  *
- *  The wrapped C-Style string.
+ *  Wraps the C-Style string @a str of length @a N.
  */
 
-//-Constructor-------------------------------------------------------------------------------------------------
+//-Instance Functions----------------------------------------------------------------------------------------------------
 //Public:
 /*!
- * @fn StringLiteral<N>::StringLiteral(const char (&str)[N])
+ *  @fn const C* TStringLiteral::data() const
  *
- *  Wraps the C-Style string @a str of length @a N.
+ *  Returns a pointer to the c-style string.
+ */
+
+/*!
+ *  @fn size_t TStringLiteral::size() const
+ *
+ *  Returns the size of the string.
+ */
+
+//-Operators-------------------------------------------------------------------------------------------------------
+//Public:
+/*!
+ *  @fn bool TStringLiteral::operator<=>(const TStringLiteral& other) const
+ *
+ *  Returns @c true if the TStringLiteral is equal to @a other; otherwise, returns @c false.
+ */
+
+/*!
+ *  @fn auto TStringLiteral::operator+(const TStringLiteral<C, M>& other) const
+ *
+ *  Returns a string which is the result of concatenating @c this and @a other.
+ */
+
+//===============================================================================================================
+// <file>
+//===============================================================================================================
+
+/*!
+ *  @typedef StringLiteral
+ *
+ *  A TStringLiteral with character type @c char.
+ */
+
+/*!
+ *  @typedef StringLiteral16
+ *
+ *  A TStringLiteral with character type @c char16_t.
  */
 }