Merge pull request #28 from rsl-org/feature/stringification

implement constexpr to_string and enum stringification

Author: Tsche

include/rsl/_impl/format/fmt_parser.hpp

@@ -8,8 +8,8 @@
 
 #include <rsl/string_view>
 #include <rsl/span>
+#include <rsl/serialize>
 
-#include <rsl/_impl/util/to_string.hpp>
 #include <rsl/_impl/parser.hpp>
 
 #include "accessor.hpp"
@@ -119,7 +119,7 @@ struct Replacement final : _impl::Parser {
     }
 
     out.string += '{';
-    out.string += util::utos(index);
+    out.string += to_string(index);
     if (!specs.empty()) {
       out.string += ":";
       out.string += specs;
@@ -189,7 +189,7 @@ struct Replacement final : _impl::Parser {
       type = remove_cvref(type);
       std::meta::info accessor{};
       if (std::ranges::all_of(subfield, _impl::is_digit)) {
-        index = util::stou(std::string_view{subfield});
+        index = _serialize_impl::stou(std::string_view{subfield});
         if (is_subscriptable(type)) {
           // member access by subscript operator
           type     = substitute(^^subscript_result, {type});
@@ -273,7 +273,7 @@ struct FormatParser : _impl::Parser {
         } break;
         case ReplacementType::indexed: {
           has_positional = true;
-          index          = util::stou(replacement.field);
+          index          = _serialize_impl::stou(replacement.field);
           if (direct[index] == -1) {
             result.accessors.push_back(get_arg_accessor(index));
             direct[index] = int(result.accessors.size() - 1);
@@ -289,7 +289,7 @@ struct FormatParser : _impl::Parser {
               throw "implicit 0. not allowed with more than one arg";
             }
           } else {
-            index             = util::stou(replacement.field.substr(0, dot_pos));
+            index             = _serialize_impl::stou(replacement.field.substr(0, dot_pos));
             replacement.field = replacement.field.substr(dot_pos + 1);
           }
           result.accessors.push_back(replacement.get_accessor(index, arg_types[index]));

include/rsl/_impl/serialize/enum.hpp

@@ -0,0 +1,30 @@
+#pragma once
+#include <meta>
+#include <ranges>
+#include <algorithm>
+#include <bit>
+
+namespace rsl::_serialize_impl {
+template <typename T>
+struct Enumerator {
+  T value;
+  char const* name;
+};
+
+template <typename T>
+consteval auto sorted_enum_pairs() {
+  auto enumerators =
+      std::vector(std::from_range, enumerators_of(^^T) | std::views::transform([](auto e) {
+                                     return Enumerator(extract<T>(constant_of(e)),
+                                                       define_static_string(identifier_of(e)));
+                                   }));
+
+  using sort_t = std::make_unsigned_t<std::underlying_type_t<T>>;
+  std::ranges::stable_sort(enumerators, std::ranges::greater{}, [](auto const& e) {
+    return std::popcount(static_cast<sort_t>(e.value));
+  });
+
+  return enumerators;
+}
+
+}  // namespace rsl::_serialize_impl

include/rsl/_impl/util/operators.hpp include/rsl/_impl/serialize/operators.hppinclude/rsl/_impl/util/operators.hpp renamed to include/rsl/_impl/serialize/operators.hpp

@@ -3,8 +3,8 @@
 #include <string>
 #include <rsl/_impl/hash.hpp>
 
-namespace rsl::util {
-constexpr std::string to_string(std::meta::operators op) {
+namespace rsl::_serialize_impl {
+constexpr std::string op_to_string(std::meta::operators op) {
   switch (op) {
     using enum std::meta::operators;
     case op_new: return "new";
@@ -112,4 +112,4 @@ constexpr std::meta::operators to_operator(std::string_view text) {
   }
   return {};
 }
-}  // namespace rsl::util
+}  // namespace rsl::_impl

include/rsl/_impl/serialize/to_string.hpp

@@ -0,0 +1,22 @@
+#pragma once
+#include <string>
+#include <cstdint>
+
+namespace rsl::_serialize_impl {
+constexpr std::string utos(std::uint64_t value) {
+  std::string out{};
+  do {
+    out += static_cast<char>('0' + (value % 10U));
+    value /= 10;
+  } while (value > 0);
+  return {out.rbegin(), out.rend()};
+}
+
+constexpr std::uint64_t stou(std::string_view str) {
+  unsigned result = 0;
+  for (char const c : str) {
+    (result *= 10) += c - '0';
+  }
+  return result;
+}
+}  // namespace rsl::_serialize_impl

include/rsl/_impl/traits.hpp

@@ -0,0 +1,39 @@
+#pragma once
+#include <type_traits>
+
+namespace rsl::_impl {
+template <class T>
+inline const bool is_signed_integer_v = false;
+template <>
+inline const bool is_signed_integer_v<signed char> = true;
+template <>
+inline const bool is_signed_integer_v<signed short> = true;
+template <>
+inline const bool is_signed_integer_v<signed int> = true;
+template <>
+inline const bool is_signed_integer_v<signed long> = true;
+template <>
+inline const bool is_signed_integer_v<signed long long> = true;
+
+template <class T>
+inline const bool is_unsigned_integer_v = false;
+template <>
+inline const bool is_unsigned_integer_v<unsigned char> = true;
+template <>
+inline const bool is_unsigned_integer_v<unsigned short> = true;
+template <>
+inline const bool is_unsigned_integer_v<unsigned int> = true;
+template <>
+inline const bool is_unsigned_integer_v<unsigned long> = true;
+template <>
+inline const bool is_unsigned_integer_v<unsigned long long> = true;
+
+template <class T>
+concept signed_integer = is_signed_integer_v<T>;
+
+template <class T>
+concept unsigned_integer = is_unsigned_integer_v<T>;
+
+template <class T>
+concept integer_type = signed_integer<T> or unsigned_integer<T>;
+}  // namespace rsl::_impl

include/rsl/_impl/util/to_string.hpp

@@ -11,8 +11,8 @@
 #include <rsl/source_location>
 #include <rsl/expect>
 #include <rsl/string_view>
+#include <rsl/serialize>
 
-#include <rsl/_impl/util/to_string.hpp>
 #include <rsl/_impl/_config.h>
 
 namespace rsl {
@@ -23,8 +23,8 @@ consteval void error() {
 }
 
 constexpr std::string format_sloc(std::source_location sloc) {
-  return std::string(sloc.file_name()) + ":" + util::to_string(sloc.line()) + ":" +
-         util::to_string(sloc.column());
+  return std::string(sloc.file_name()) + ":" + to_string(sloc.line()) + ":" +
+         to_string(sloc.column());
 }
 }  // namespace _error_impl