added more operators; added tests

src/include/units/symbol_text.h

@@ -29,40 +29,260 @@ struct basic_symbol_text {
         lhs.standard_ + rhs.standard_, lhs.ascii_ + rhs.ascii_);
   }
 
-  template<typename CharT, std::size_t N2>
+  template<std::size_t N2>
   [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + N2, M + N2> operator+(
-      const basic_symbol_text& lhs, const basic_fixed_string<CharT, N2>& rhs) noexcept
+      const basic_symbol_text& lhs, const basic_fixed_string<StandardCharT, N2>& rhs) noexcept
   {
-    return basic_symbol_text<StandardCharT, ASCIICharT, N + N2, M + N2>(
-        lhs.standard_ + rhs, lhs.ascii_ + rhs);
+    return (lhs + basic_symbol_text<StandardCharT, StandardCharT, N2, N2>(rhs));
   }
   
-  template<typename CharT, std::size_t N2>
+  template<std::size_t N2>
   [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + N2, M + N2> operator+(
-      const basic_fixed_string<CharT, N2>& lhs, const basic_symbol_text& rhs) noexcept
+      const basic_fixed_string<StandardCharT, N2>& lhs, const basic_symbol_text& rhs) noexcept
   {
-    return basic_symbol_text<StandardCharT, ASCIICharT, N + N2, M + N2>(
-        lhs + rhs.standard_, lhs + rhs.ascii_);
+    return (basic_symbol_text<StandardCharT, StandardCharT, N2, N2>(lhs) + rhs);
+  }
+
+  template<std::size_t N2>
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + N2 - 1, M + N2 - 1> operator+(
+      const basic_symbol_text& lhs, const StandardCharT (&rhs)[N2]) noexcept
+  {
+    return (lhs + basic_symbol_text<StandardCharT, StandardCharT, N2 - 1, N2 - 1>(rhs));
+  }
+  
+  template<std::size_t N2>
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + N2 - 1, M + N2 - 1> operator+(
+      const StandardCharT (&lhs)[N2], const basic_symbol_text& rhs) noexcept
+  {
+    return (basic_symbol_text<StandardCharT, StandardCharT, N2 - 1, N2 - 1>(lhs) + rhs);
+  }
+
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + 1, M + 1> operator+(
+      const basic_symbol_text& lhs, StandardCharT rhs) noexcept
+  {
+    return (lhs + basic_symbol_text<StandardCharT, StandardCharT, 1, 1>(rhs));
+  }
+  
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + 1, M + 1> operator+(
+      StandardCharT lhs, const basic_symbol_text& rhs) noexcept
+  {
+    return (basic_symbol_text<StandardCharT, StandardCharT, 1, 1>(lhs) + rhs);
+  }
+
+  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text& lhs,
+                                                 const basic_symbol_text& rhs) noexcept
+  {
+    return (lhs.standard_ == rhs.standard_ && lhs.ascii_ == rhs.ascii_);
+  }
+
+  [[nodiscard]] constexpr friend bool operator!=(const basic_symbol_text& lhs,
+                                                 const basic_symbol_text& rhs) noexcept
+  {
+    return !(lhs == rhs);
+  }
+
+  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text&,
+                                                 const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>&) noexcept
+  {
+    return false;
+  }
+
+  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  [[nodiscard]] constexpr friend bool operator!=(const basic_symbol_text&,
+                                                 const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>&) noexcept
+  {
+    return true;
+  }
+
+  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text& lhs,
+                                                 const basic_fixed_string<StandardCharT, N>& rhs) noexcept
+  {
+    return (lhs.standard_ == rhs);
+  }
+
+  [[nodiscard]] constexpr friend bool operator!=(const basic_symbol_text& lhs,
+                                                 const basic_fixed_string<StandardCharT, N>& rhs) noexcept
+  {
+    return !(lhs == rhs);
+  }
+  
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text&,
+                                                 const basic_fixed_string<StandardCharT2, N2>&) noexcept
+  {
+    return false;
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator!=(const basic_symbol_text&,
+                                                 const basic_fixed_string<StandardCharT2, N2>&) noexcept
+  {
+    return true;
+  }
+  
+  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text& lhs,
+                                                 const StandardCharT (&rhs)[N + 1]) noexcept
+  {
+    return (lhs.standard_ == rhs);
+  }
+
+  [[nodiscard]] constexpr friend bool operator!=(const basic_symbol_text& lhs,
+                                                 const StandardCharT (&rhs)[N + 1]) noexcept
+  {
+    return !(lhs == rhs);
+  }
+  
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text&,
+                                                 const StandardCharT2 (&)[N2 + 1]) noexcept
+  {
+    return false;
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator!=(const basic_symbol_text&,
+                                                 const StandardCharT2 (&)[N2 + 1]) noexcept
+  {
+    return true;
+  }
+
+  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text& lhs,
+                                                 StandardCharT rhs) noexcept
+  {
+    return (lhs.standard_ == rhs);
+  }
+
+  [[nodiscard]] constexpr friend bool operator!=(const basic_symbol_text& lhs,
+                                                 StandardCharT rhs) noexcept
+  {
+    return !(lhs == rhs);
+  }
+
+  template<typename StandardCharT2>
+  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text&,
+                                                 StandardCharT2) noexcept
+  {
+    return false;
+  }
+
+  template<typename StandardCharT2>
+  [[nodiscard]] constexpr friend bool operator!=(const basic_symbol_text&,
+                                                 StandardCharT2) noexcept
+  {
+    return true;
   }
 
   template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
   [[nodiscard]] constexpr friend bool operator<(const basic_symbol_text& lhs,
-        const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>& rhs) noexcept
+                                                const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>& rhs) noexcept
   {
     return (lhs.standard_ < rhs.standard_);
   }
 
-  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text& lhs,
-                                                 const StandardCharT (&rhs)[N + 1]) noexcept
-  {
-    return (lhs.standard_ == basic_fixed_string(rhs));
-  }
-  
   template<typename StandardCharT2, std::size_t N2>
-  [[nodiscard]] constexpr friend bool operator==(const basic_symbol_text& lhs,
-                                                 const StandardCharT2 (&rhs)[N2 + 1]) noexcept
+  [[nodiscard]] constexpr friend bool operator<(const basic_symbol_text& lhs,
+                                                const basic_fixed_string<StandardCharT2, N2>& rhs) noexcept
   {
-    return false;
+    return (lhs.standard_ < rhs);
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator<(const basic_symbol_text& lhs,
+                                                const StandardCharT2 (&rhs)[N2]) noexcept
+  {
+    return (lhs.standard_ < basic_fixed_string(rhs));
+  }
+
+  template<typename StandardCharT2>
+  [[nodiscard]] constexpr friend bool operator<(const basic_symbol_text& lhs,
+                                                StandardCharT2 rhs) noexcept
+  {
+    return (lhs.standard_ < basic_fixed_string(rhs));
+  }
+
+  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  [[nodiscard]] constexpr friend bool operator>(const basic_symbol_text& lhs,
+                                                const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>& rhs) noexcept
+  {
+    return (lhs.standard_ > rhs.standard_);
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator>(const basic_symbol_text& lhs,
+        const basic_fixed_string<StandardCharT2, N2>& rhs) noexcept
+  {
+    return (lhs.standard_ > rhs);
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator>(const basic_symbol_text& lhs,
+        const StandardCharT2 (&rhs)[N2]) noexcept
+  {
+    return (lhs.standard_ > basic_fixed_string(rhs));
+  }
+
+  template<typename StandardCharT2>
+  [[nodiscard]] constexpr friend bool operator>(const basic_symbol_text& lhs,
+                                                StandardCharT2 rhs) noexcept
+  {
+    return (lhs.standard_ > basic_fixed_string(rhs));
+  }
+
+  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  [[nodiscard]] constexpr friend bool operator<=(const basic_symbol_text& lhs,
+                                                 const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>& rhs) noexcept
+  {
+    return (lhs.standard_ <= rhs.standard_);
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator<=(const basic_symbol_text& lhs,
+                                                 const basic_fixed_string<StandardCharT2, N2>& rhs) noexcept
+  {
+    return (lhs.standard_ <= rhs);
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator<=(const basic_symbol_text& lhs,
+                                                 const StandardCharT2 (&rhs)[N2]) noexcept
+  {
+    return (lhs.standard_ <= basic_fixed_string(rhs));
+  }
+
+  template<typename StandardCharT2>
+  [[nodiscard]] constexpr friend bool operator<=(const basic_symbol_text& lhs,
+                                                 StandardCharT2 rhs) noexcept
+  {
+    return (lhs.standard_ <= basic_fixed_string(rhs));
+  }
+
+  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  [[nodiscard]] constexpr friend bool operator>=(const basic_symbol_text& lhs,
+                                                 const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>& rhs) noexcept
+  {
+    return (lhs.standard_ >= rhs.standard_);
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator>=(const basic_symbol_text& lhs,
+                                                 const basic_fixed_string<StandardCharT2, N2>& rhs) noexcept
+  {
+    return (lhs.standard_ >= rhs);
+  }
+
+  template<typename StandardCharT2, std::size_t N2>
+  [[nodiscard]] constexpr friend bool operator>=(const basic_symbol_text& lhs,
+                                                 const StandardCharT2 (&rhs)[N2]) noexcept
+  {
+    return (lhs.standard_ >= basic_fixed_string(rhs));
+  }
+
+  template<typename StandardCharT2>
+  [[nodiscard]] constexpr friend bool operator>=(const basic_symbol_text& lhs,
+                                                 StandardCharT2 rhs) noexcept
+  {
+    return (lhs.standard_ >= basic_fixed_string(rhs));
   }
 };
 
@@ -76,14 +296,14 @@ template<typename StandardCharT, std::size_t N>
 basic_symbol_text(const StandardCharT (&)[N]) -> basic_symbol_text<StandardCharT, StandardCharT, N - 1, N - 1>;
 
 template<typename StandardCharT, std::size_t N>
-basic_symbol_text(const basic_fixed_string<StandardCharT, N>& s) -> basic_symbol_text<StandardCharT, StandardCharT, N - 1, N - 1>;
+basic_symbol_text(const basic_fixed_string<StandardCharT, N>&) -> basic_symbol_text<StandardCharT, StandardCharT, N, N>;
 
 template<typename StandardCharT, typename ASCIICharT, std::size_t N, std::size_t M>
 basic_symbol_text(const StandardCharT (&)[N], const ASCIICharT (&)[M]) -> basic_symbol_text<StandardCharT, ASCIICharT, N - 1, M - 1>;
 
 template<typename StandardCharT, typename ASCIICharT, std::size_t N, std::size_t M>
-basic_symbol_text(const basic_fixed_string<StandardCharT, N>& s,
-                  const basic_fixed_string<ASCIICharT, M>& a)
--> basic_symbol_text<StandardCharT, ASCIICharT, N - 1, M - 1>;
+basic_symbol_text(const basic_fixed_string<StandardCharT, N>&,
+                  const basic_fixed_string<ASCIICharT, M>&)
+-> basic_symbol_text<StandardCharT, ASCIICharT, N, M>;
 
 }  // namespace units

test/unit_test/static/CMakeLists.txt

@@ -28,6 +28,7 @@ add_library(unit_tests_static
     dimension_op_test.cpp
     dimensions_concepts_test.cpp
     fixed_string_test.cpp
+    fixed_symbol_test.cpp
     math_test.cpp
     quantity_test.cpp
     ratio_test.cpp

test/unit_test/static/fixed_symbol_test.cpp

@@ -0,0 +1,91 @@
+#include "units/symbol_text.h"
+
+using namespace units;
+
+namespace {
+
+constexpr basic_symbol_text sym1('b');
+static_assert(sym1 == 'b');
+static_assert(sym1 != 'a');
+static_assert(sym1 != "ab");
+static_assert(sym1 < 'c');
+static_assert(sym1 > 'a');
+static_assert(sym1 <= 'b');
+static_assert(sym1 <= 'c');
+static_assert(sym1 >= 'b');
+static_assert(sym1 >= 'a');
+static_assert(sym1.standard() == 'b');
+static_assert(sym1.ascii() == 'b');
+
+constexpr basic_symbol_text sym2('a', 'b');
+static_assert(sym2 == 'a');
+static_assert(sym2 != 'b');
+static_assert(sym2.standard() == 'a');
+static_assert(sym2.ascii() == 'b');
+
+constexpr basic_symbol_text sym3("ab");
+static_assert(sym3.standard() == "ab");
+static_assert(sym3.ascii() == "ab");
+
+constexpr basic_fixed_string txt1("bc");
+constexpr basic_symbol_text sym4(txt1);
+static_assert(sym4.standard() == "bc");
+static_assert(sym4.ascii() == "bc");
+
+constexpr basic_symbol_text sym5("bc", "de");
+static_assert(sym5.standard() == "bc");
+static_assert(sym5.ascii() == "de");
+
+constexpr basic_fixed_string txt2("de");
+constexpr basic_symbol_text sym6(txt1, txt2);
+static_assert(sym6.standard() == "bc");
+static_assert(sym6.ascii() == "de");
+
+static_assert(sym6 == basic_symbol_text("bc", "de"));
+static_assert(sym6 != basic_symbol_text("bc", "bc"));
+static_assert(sym6 != basic_symbol_text("de", "de"));
+static_assert(sym6 != basic_symbol_text("bcd", "ef"));
+static_assert(sym6 != basic_symbol_text("bc", "def"));
+
+static_assert(sym6 == basic_fixed_string("bc"));
+static_assert(sym6 != basic_fixed_string("de"));
+static_assert(sym6 != basic_fixed_string("fg"));
+static_assert(sym6 != basic_fixed_string("bcd"));
+
+static_assert(sym6 == "bc");
+static_assert(sym6 != "de");
+static_assert(sym6 != "fg");
+static_assert(sym6 != "bcd");
+
+static_assert(sym6 < basic_fixed_string("c"));
+static_assert(sym6 > basic_fixed_string("a"));
+static_assert(sym6 <= basic_fixed_string("c"));
+static_assert(sym6 <= basic_fixed_string("bcd"));
+static_assert(sym6 >= basic_fixed_string("a"));
+static_assert(sym6 >= basic_fixed_string("bc"));
+
+static_assert(sym6 < "c");
+static_assert(sym6 > "a");
+static_assert(sym6 <= "c");
+static_assert(sym6 <= "bcd");
+static_assert(sym6 >= "a");
+static_assert(sym6 >= "bc");
+
+static_assert(basic_symbol_text("a") + sym4 == basic_symbol_text("abc"));
+static_assert(sym4 + basic_symbol_text("f") == basic_symbol_text("bcf"));
+
+static_assert(basic_fixed_string("a") + sym4 == basic_symbol_text("abc"));
+static_assert(sym4 + basic_fixed_string("f") == basic_symbol_text("bcf"));
+
+static_assert(basic_symbol_text("a", "f") + sym6 == basic_symbol_text("abc", "fde"));
+static_assert(sym6 + basic_symbol_text("a", "f") == basic_symbol_text("bca", "def"));
+
+static_assert('a' + sym6 == basic_symbol_text("abc", "ade"));
+static_assert(sym6 + 'f' == basic_symbol_text("bcf", "def"));
+
+static_assert(basic_fixed_string("a") + sym6 == basic_symbol_text("abc", "ade"));
+static_assert(sym6 + basic_fixed_string("f") == basic_symbol_text("bcf", "def"));
+
+static_assert("a" + sym6 == basic_symbol_text("abc", "ade"));
+static_assert(sym6 + "f" == basic_symbol_text("bcf", "def"));
+}