From a3d4e04645e8a1150adebd1e5feb5d5533c6de6c Mon Sep 17 00:00:00 2001
From: Ramzi Sabra <yasamoka@hotmail.com>
Date: Thu, 26 Mar 2020 08:27:56 +0200
Subject: [PATCH] replaced ASCIICharT typename with char

---
 src/include/units/symbol_text.h | 92 ++++++++++++++++-----------------
 1 file changed, 46 insertions(+), 46 deletions(-)

diff --git a/src/include/units/symbol_text.h b/src/include/units/symbol_text.h
index 2c79915b..ed64b4cf 100644
--- a/src/include/units/symbol_text.h
+++ b/src/include/units/symbol_text.h
@@ -5,17 +5,17 @@
 
 namespace units {
 
-template<typename StandardCharT, typename ASCIICharT, std::size_t N, std::size_t M>
+template<typename StandardCharT, std::size_t N, std::size_t M>
 struct basic_symbol_text {
   basic_fixed_string<StandardCharT, N> standard_;
-  basic_fixed_string<ASCIICharT, M> ascii_;
+  basic_fixed_string<char, M> ascii_;
 
   constexpr basic_symbol_text(StandardCharT s) noexcept: standard_(s), ascii_(s) {}
-  constexpr basic_symbol_text(StandardCharT s, ASCIICharT a) noexcept: standard_(s), ascii_(a) {}
+  constexpr basic_symbol_text(StandardCharT s, char a) noexcept: standard_(s), ascii_(a) {}
   constexpr basic_symbol_text(const StandardCharT (&s)[N + 1]) noexcept: standard_(s), ascii_(s) {}
   constexpr basic_symbol_text(const basic_fixed_string<StandardCharT, N>& s) noexcept: standard_(s), ascii_(s) {}
-  constexpr basic_symbol_text(const StandardCharT (&s)[N + 1], const ASCIICharT (&a)[M + 1]) noexcept: standard_(s), ascii_(a) {}
-  constexpr basic_symbol_text(const basic_fixed_string<StandardCharT, N>& s, const basic_fixed_string<ASCIICharT, M>& a) noexcept: standard_(s), ascii_(a) {}
+  constexpr basic_symbol_text(const StandardCharT (&s)[N + 1], const char (&a)[M + 1]) noexcept: standard_(s), ascii_(a) {}
+  constexpr basic_symbol_text(const basic_fixed_string<StandardCharT, N>& s, const basic_fixed_string<char, M>& a) noexcept: standard_(s), ascii_(a) {}
 
   [[nodiscard]] constexpr auto& standard() { return standard_; }
   [[nodiscard]] constexpr const auto& standard() const { return standard_; }
@@ -23,58 +23,58 @@ struct basic_symbol_text {
   [[nodiscard]] constexpr const auto& ascii() const { return ascii_; }
 
   template<std::size_t N2, std::size_t M2>
-  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + N2, M + M2> operator+(
-      const basic_symbol_text& lhs, const basic_symbol_text<StandardCharT, ASCIICharT, N2, M2>& rhs) noexcept
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, N + N2, M + M2> operator+(
+      const basic_symbol_text& lhs, const basic_symbol_text<StandardCharT, N2, M2>& rhs) noexcept
   {
-    return basic_symbol_text<StandardCharT, ASCIICharT, N + N2, M + M2>(
+    return basic_symbol_text<StandardCharT, N + N2, M + M2>(
         lhs.standard_ + rhs.standard_, lhs.ascii_ + rhs.ascii_);
   }
 
   template<std::size_t N2>
-  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + N2, M + N2> operator+(
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, N + N2, M + N2> operator+(
       const basic_symbol_text& lhs, const basic_fixed_string<StandardCharT, N2>& rhs) noexcept
   {
-    return lhs + basic_symbol_text<StandardCharT, StandardCharT, N2, N2>(rhs);
+    return lhs + basic_symbol_text<StandardCharT, N2, N2>(rhs);
   }
   
   template<std::size_t N2>
-  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + N2, M + N2> operator+(
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, N + N2, M + N2> operator+(
       const basic_fixed_string<StandardCharT, N2>& lhs, const basic_symbol_text& rhs) noexcept
   {
-    return basic_symbol_text<StandardCharT, StandardCharT, N2, N2>(lhs) + rhs;
+    return basic_symbol_text<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+(
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, 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);
+    return lhs + basic_symbol_text<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+(
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, 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;
+    return basic_symbol_text<StandardCharT, N2 - 1, N2 - 1>(lhs) + rhs;
   }
 
-  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + 1, M + 1> operator+(
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, N + 1, M + 1> operator+(
       const basic_symbol_text& lhs, StandardCharT rhs) noexcept
   {
-    return lhs + basic_symbol_text<StandardCharT, StandardCharT, 1, 1>(rhs);
+    return lhs + basic_symbol_text<StandardCharT, 1, 1>(rhs);
   }
   
-  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, ASCIICharT, N + 1, M + 1> operator+(
+  [[nodiscard]] constexpr friend basic_symbol_text<StandardCharT, N + 1, M + 1> operator+(
       StandardCharT lhs, const basic_symbol_text& rhs) noexcept
   {
-    return basic_symbol_text<StandardCharT, StandardCharT, 1, 1>(lhs) + rhs;
+    return basic_symbol_text<StandardCharT, 1, 1>(lhs) + rhs;
   }
 
 #if __GNUC__ >= 10
 
-  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  template<typename StandardCharT2, std::size_t N2, std::size_t M2>
   [[nodiscard]] friend constexpr auto operator<=>(const basic_symbol_text& lhs,
-                                                  const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>& rhs)
+                                                  const basic_symbol_text<StandardCharT2, N2, M2>& rhs)
   {
     auto comparison = std::lexicographical_compare_three_way(lhs.standard_.begin(), lhs.standard_.end(), rhs.standard_.begin(), rhs.standard_.end());
     assert(std::lexicographical_compare_three_way(lhs.ascii_.begin(), lhs.ascii_.end(), rhs.ascii_.begin(), rhs.ascii_.end()) == comparison);
@@ -102,9 +102,9 @@ struct basic_symbol_text {
     return lhs <=> basic_fixed_string<StandardCharT2, 1>(rhs);
   }
 
-  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  template<typename StandardCharT2, std::size_t N2, std::size_t M2>
   [[nodiscard]] friend constexpr bool operator==(const basic_symbol_text& lhs,
-                                                 const basic_symbol_text<StandardCharT2, ASCIICharT2, N2, M2>& rhs)
+                                                 const basic_symbol_text<StandardCharT2, N2, M2>& rhs)
   {
     bool comparison = std::equal(lhs.standard_.begin(), lhs.standard_.end(), rhs.standard_.begin(), rhs.standard_.end());
     assert(std::equal(lhs.ascii_.begin(), lhs.ascii_.end(), rhs.ascii_.begin(), rhs.ascii_.end()) == comparison);
@@ -134,18 +134,18 @@ struct basic_symbol_text {
 
 #else
 
-  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  template<typename StandardCharT2, 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, N2, M2>& rhs) noexcept
   {
     bool comparison = (lhs.standard_ == rhs.standard_);
     assert((lhs.ascii_ == rhs.ascii_) == comparison);
     return comparison;
   }
 
-  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  template<typename StandardCharT2, 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, N2, M2>& rhs) noexcept
   {
     return !(lhs == rhs);
   }
@@ -228,9 +228,9 @@ struct basic_symbol_text {
     return true;
   }
 
-  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  template<typename StandardCharT2, 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, N2, M2>& rhs) noexcept
   {
     bool comparison = lhs.standard_ < rhs.standard_;
     assert((lhs.ascii_ < rhs.ascii_) == comparison);
@@ -258,9 +258,9 @@ struct basic_symbol_text {
     return lhs.standard_ < basic_fixed_string(rhs);
   }
 
-  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  template<typename StandardCharT2, 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, N2, M2>& rhs) noexcept
   {
     bool comparison = lhs.standard_ > rhs.standard_;
     assert((lhs.ascii_ > rhs.ascii_) == comparison);
@@ -288,9 +288,9 @@ struct basic_symbol_text {
     return lhs.standard_ > basic_fixed_string(rhs);
   }
 
-  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  template<typename StandardCharT2, 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, N2, M2>& rhs) noexcept
   {
     bool comparison = lhs.standard_ <= rhs.standard_;
     assert((lhs.ascii_ <= rhs.ascii_) == comparison);
@@ -318,9 +318,9 @@ struct basic_symbol_text {
     return lhs.standard_ <= basic_fixed_string(rhs);
   }
 
-  template<typename StandardCharT2, typename ASCIICharT2, std::size_t N2, std::size_t M2>
+  template<typename StandardCharT2, 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, N2, M2>& rhs) noexcept
   {
     bool comparison = lhs.standard_ >= rhs.standard_;
     assert((lhs.ascii_ >= rhs.ascii_) == comparison);
@@ -353,23 +353,23 @@ struct basic_symbol_text {
 };
 
 template<typename StandardCharT>
-basic_symbol_text(StandardCharT) -> basic_symbol_text<StandardCharT, StandardCharT, 1, 1>;
+basic_symbol_text(StandardCharT) -> basic_symbol_text<StandardCharT, 1, 1>;
 
-template<typename StandardCharT, typename ASCIICharT>
-basic_symbol_text(StandardCharT, ASCIICharT) -> basic_symbol_text<StandardCharT, ASCIICharT, 1, 1>;
+template<typename StandardCharT>
+basic_symbol_text(StandardCharT, char) -> basic_symbol_text<StandardCharT, 1, 1>;
 
 template<typename StandardCharT, std::size_t N>
-basic_symbol_text(const StandardCharT (&)[N]) -> basic_symbol_text<StandardCharT, StandardCharT, N - 1, N - 1>;
+basic_symbol_text(const StandardCharT (&)[N]) -> basic_symbol_text<StandardCharT, N - 1, N - 1>;
 
 template<typename StandardCharT, std::size_t N>
-basic_symbol_text(const basic_fixed_string<StandardCharT, N>&) -> basic_symbol_text<StandardCharT, StandardCharT, N, N>;
+basic_symbol_text(const basic_fixed_string<StandardCharT, N>&) -> basic_symbol_text<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, std::size_t N, std::size_t M>
+basic_symbol_text(const StandardCharT (&)[N], const char (&)[M]) -> basic_symbol_text<StandardCharT, N - 1, M - 1>;
 
-template<typename StandardCharT, typename ASCIICharT, std::size_t N, std::size_t M>
+template<typename StandardCharT, std::size_t N, std::size_t M>
 basic_symbol_text(const basic_fixed_string<StandardCharT, N>&,
-                  const basic_fixed_string<ASCIICharT, M>&)
--> basic_symbol_text<StandardCharT, ASCIICharT, N, M>;
+                  const basic_fixed_string<char, M>&)
+-> basic_symbol_text<StandardCharT, N, M>;
 
 }  // namespace units