From 54061a3bee62ea6e0f8ccae6bb3bba4bae0ec0a0 Mon Sep 17 00:00:00 2001
From: Patrick Urbanke <patrick@getml.com>
Date: Sun, 28 Apr 2024 15:01:09 +0200
Subject: [PATCH] Added SnakeCaseToHungarianCase

---
 include/rfl.hpp                               |  1 +
 include/rfl/SnakeCaseToCamelCase.hpp          | 44 ++++---------------
 include/rfl/SnakeCaseToHungarianCase.hpp      | 34 ++++++++++++++
 include/rfl/internal/transform_snake_case.hpp | 36 +++++++++++++++
 .../test_snake_case_to_hungarian_case.cpp     | 40 +++++++++++++++++
 5 files changed, 119 insertions(+), 36 deletions(-)
 create mode 100644 include/rfl/SnakeCaseToHungarianCase.hpp
 create mode 100644 include/rfl/internal/transform_snake_case.hpp
 create mode 100644 tests/json/test_snake_case_to_hungarian_case.cpp

diff --git a/include/rfl.hpp b/include/rfl.hpp
index 91c90e77..8b4db705 100644
--- a/include/rfl.hpp
+++ b/include/rfl.hpp
@@ -23,6 +23,7 @@
 #include "rfl/Rename.hpp"
 #include "rfl/Size.hpp"
 #include "rfl/SnakeCaseToCamelCase.hpp"
+#include "rfl/SnakeCaseToHungarianCase.hpp"
 #include "rfl/TaggedUnion.hpp"
 #include "rfl/Timestamp.hpp"
 #include "rfl/Validator.hpp"
diff --git a/include/rfl/SnakeCaseToCamelCase.hpp b/include/rfl/SnakeCaseToCamelCase.hpp
index c8c377cd..86d6a952 100644
--- a/include/rfl/SnakeCaseToCamelCase.hpp
+++ b/include/rfl/SnakeCaseToCamelCase.hpp
@@ -1,57 +1,29 @@
 #ifndef RFL_SNAKECASETOCAMELCASE_HPP_
 #define RFL_SNAKECASETOCAMELCASE_HPP_
 
-#include <array>
-#include <string_view>
-
 #include "Field.hpp"
-#include "internal/StringLiteral.hpp"
+#include "internal/transform_snake_case.hpp"
 
 namespace rfl {
-namespace internal {
-/// Capitalizes a lower-case character.
-template <char c>
-consteval char to_upper() {
-  if constexpr (c >= 'a' && c <= 'z') {
-    return c + ('A' - 'a');
-  } else {
-    return c;
-  }
-}
-
-/// Transforms the field name from snake case to camel case.
-template <internal::StringLiteral _name, bool _capitalize, size_t _i = 0,
-          char... chars>
-consteval auto transform_field_name() {
-  if constexpr (_i == _name.arr_.size()) {
-    return StringLiteral<sizeof...(chars) + 1>(chars...);
-  } else if constexpr (_name.arr_[_i] == '_') {
-    return transform_field_name<_name, true, _i + 1, chars...>();
-  } else if constexpr (_capitalize) {
-    return transform_field_name<_name, false, _i + 1, chars...,
-                                to_upper<_name.arr_[_i]>()>();
-  } else {
-    return transform_field_name<_name, false, _i + 1, chars...,
-                                _name.arr_[_i]>();
-  }
-}
-}  // namespace internal
 
 struct SnakeCaseToCamelCase {
  public:
   /// Replaces all instances of snake_case field names with CamelCase.
   template <class StructType>
-  static auto process(auto _named_tuple) {
-    const auto handle_one = [](const auto& _f) { return handle_one_field(_f); };
+  static auto process(auto&& _named_tuple) {
+    const auto handle_one = [](auto&& _f) {
+      return handle_one_field(std::move(_f));
+    };
     return _named_tuple.transform(handle_one);
   }
 
  private:
   /// Applies the logic to a single field.
   template <class FieldType>
-  static auto handle_one_field(const FieldType& _f) {
+  static auto handle_one_field(FieldType&& _f) {
     using NewFieldType =
-        Field<internal::transform_field_name<FieldType::name_, true>(),
+        Field<internal::transform_snake_case<FieldType::name_,
+                                             /*capitalize=*/true>(),
               typename FieldType::Type>;
     return NewFieldType(_f.value());
   }
diff --git a/include/rfl/SnakeCaseToHungarianCase.hpp b/include/rfl/SnakeCaseToHungarianCase.hpp
new file mode 100644
index 00000000..a7bff44b
--- /dev/null
+++ b/include/rfl/SnakeCaseToHungarianCase.hpp
@@ -0,0 +1,34 @@
+#ifndef RFL_SNAKECASETOHUNGARIANCASE_HPP_
+#define RFL_SNAKECASETOHUNGARIANCASE_HPP_
+
+#include "Field.hpp"
+#include "internal/transform_snake_case.hpp"
+
+namespace rfl {
+
+struct SnakeCaseToHungarianCase {
+ public:
+  /// Replaces all instances of snake_case field names with CamelCase.
+  template <class StructType>
+  static auto process(auto&& _named_tuple) {
+    const auto handle_one = [](auto&& _f) {
+      return handle_one_field(std::move(_f));
+    };
+    return _named_tuple.transform(handle_one);
+  }
+
+ private:
+  /// Applies the logic to a single field.
+  template <class FieldType>
+  static auto handle_one_field(FieldType&& _f) {
+    using NewFieldType =
+        Field<internal::transform_snake_case<FieldType::name_,
+                                             /*capitalize=*/false>(),
+              typename FieldType::Type>;
+    return NewFieldType(_f.value());
+  }
+};
+
+}  // namespace rfl
+
+#endif
diff --git a/include/rfl/internal/transform_snake_case.hpp b/include/rfl/internal/transform_snake_case.hpp
new file mode 100644
index 00000000..16092334
--- /dev/null
+++ b/include/rfl/internal/transform_snake_case.hpp
@@ -0,0 +1,36 @@
+#ifndef RFL_INTERNAL_TRANSFORMSNAKECASE_HPP_
+#define RFL_INTERNAL_TRANSFORMSNAKECASE_HPP_
+
+#include "StringLiteral.hpp"
+
+namespace rfl::internal {
+
+/// Capitalizes a lower-case character.
+template <char c>
+consteval char to_upper() {
+  if constexpr (c >= 'a' && c <= 'z') {
+    return c + ('A' - 'a');
+  } else {
+    return c;
+  }
+}
+
+/// Transforms the field name from snake case to camel case.
+template <internal::StringLiteral _name, bool _capitalize, size_t _i = 0,
+          char... chars>
+consteval auto transform_snake_case() {
+  if constexpr (_i == _name.arr_.size()) {
+    return StringLiteral<sizeof...(chars) + 1>(chars...);
+  } else if constexpr (_name.arr_[_i] == '_') {
+    return transform_snake_case<_name, true, _i + 1, chars...>();
+  } else if constexpr (_capitalize) {
+    return transform_snake_case<_name, false, _i + 1, chars...,
+                                to_upper<_name.arr_[_i]>()>();
+  } else {
+    return transform_snake_case<_name, false, _i + 1, chars...,
+                                _name.arr_[_i]>();
+  }
+}
+}  // namespace rfl::internal
+
+#endif
diff --git a/tests/json/test_snake_case_to_hungarian_case.cpp b/tests/json/test_snake_case_to_hungarian_case.cpp
new file mode 100644
index 00000000..d4afc543
--- /dev/null
+++ b/tests/json/test_snake_case_to_hungarian_case.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <source_location>
+#include <string>
+#include <vector>
+
+#include "write_and_read.hpp"
+
+namespace test_snake_case_to_hungarian_case {
+
+struct Person {
+  std::string first_name;
+  std::string last_name;
+  rfl::Timestamp<"%Y-%m-%d"> birthday;
+  std::vector<Person> children;
+};
+
+TEST(json, test_snake_case_to_hungarian_case) {
+  const auto bart = Person{
+      .first_name = "Bart", .last_name = "Simpson", .birthday = "1987-04-19"};
+
+  const auto lisa = Person{
+      .first_name = "Lisa", .last_name = "Simpson", .birthday = "1987-04-19"};
+
+  const auto maggie = Person{
+      .first_name = "Maggie", .last_name = "Simpson", .birthday = "1987-04-19"};
+
+  const auto homer =
+      Person{.first_name = "Homer",
+             .last_name = "Simpson",
+             .birthday = "1987-04-19",
+             .children = std::vector<Person>({bart, lisa, maggie})};
+
+  const auto named_tuple =
+      rfl::to_named_tuple<rfl::SnakeCaseToHungarianCase>(homer);
+
+  std::cout << rfl::json::write(named_tuple, rfl::json::pretty) << std::endl;
+}
+}  // namespace test_snake_case_to_hungarian_case