Add camel case to snake case conversion

include/rfl.hpp

@@ -41,6 +41,7 @@
 #include "rfl/Skip.hpp"
 #include "rfl/SnakeCaseToCamelCase.hpp"
 #include "rfl/SnakeCaseToPascalCase.hpp"
+#include "rfl/CamelCaseToSnakeCase.hpp"
 #include "rfl/TaggedUnion.hpp"
 #include "rfl/Timestamp.hpp"
 #include "rfl/UnderlyingEnums.hpp"

include/rfl/CamelCaseToSnakeCase.hpp

@@ -0,0 +1,38 @@
+#ifndef RFL_CAMELCASETOSNAKECASE_HPP_
+#define RFL_CAMELCASETOSNAKECASE_HPP_
+
+#include "Field.hpp"
+#include "internal/is_rename.hpp"
+#include "internal/transform_case.hpp"
+
+namespace rfl {
+
+struct CamelCaseToSnakeCase {
+ public:
+  /// Replaces all instances of camelCase field names with snake_case.
+  template <class StructType>
+  static auto process(const auto& _named_tuple) {
+    return _named_tuple.transform([]<class FieldType>(const FieldType& _f) {
+      if constexpr (FieldType::name() != "xml_content" &&
+                    !internal::is_rename_v<typename FieldType::Type>) {
+        return handle_one_field(_f);
+      } else {
+        return _f;
+      }
+    });
+  }
+
+ private:
+  /// Applies the logic to a single field.
+  template <class FieldType>
+  static auto handle_one_field(const FieldType& _f) {
+    using NewFieldType =
+        Field<internal::transform_camel_case<FieldType::name_>(),
+              typename FieldType::Type>;
+    return NewFieldType(_f.value());
+  }
+};
+
+}  // namespace rfl
+
+#endif

include/rfl/SnakeCaseToCamelCase.hpp

@@ -3,7 +3,7 @@
 
 #include "Field.hpp"
 #include "internal/is_rename.hpp"
-#include "internal/transform_snake_case.hpp"
+#include "internal/transform_case.hpp"
 
 namespace rfl {
 

include/rfl/SnakeCaseToPascalCase.hpp

@@ -3,7 +3,7 @@
 
 #include "Field.hpp"
 #include "internal/is_rename.hpp"
-#include "internal/transform_snake_case.hpp"
+#include "internal/transform_case.hpp"
 
 namespace rfl {
 

include/rfl/internal/transform_snake_case.hpp → include/rfl/internal/transform_case.hpp

@@ -24,6 +24,11 @@ consteval char to_lower() {
   }
 }
 
+template <char c>
+consteval bool is_upper() {
+  return c >= 'A' && c <= 'Z';
+}
+
 /// Transforms the field name from snake case to camel case.
 template <internal::StringLiteral _name, bool _capitalize, size_t _i = 0,
           char... chars>
@@ -50,6 +55,23 @@ consteval auto transform_snake_case() {
                                 _name.arr_[_i]>();
   }
 }
+
+/// Transforms the field name from camel case to snake case
+template <internal::StringLiteral _name, size_t _i = 0, char... chars>
+consteval auto transform_camel_case() {
+  if constexpr (_i == _name.arr_.size()) {
+    return StringLiteral<sizeof...(chars) + 1>(chars...);
+
+  } else if constexpr (_name.arr_[_i] == '\0') {
+    return transform_camel_case<_name, _name.arr_.size(), chars...>();
+
+  } else if constexpr (is_upper<_name.arr_[_i]>()) {
+    return transform_camel_case<_name, _i + 1, chars..., '_', to_lower<_name.arr_[_i]>()>();
+
+  } else {
+    return transform_camel_case<_name, _i + 1, chars..., _name.arr_[_i]>();
+  }
+}
 }  // namespace rfl::internal
 
 #endif

src/rfl/internal/strings/strings.cpp

@@ -60,6 +60,7 @@ std::vector<std::string> split(const std::string& _str,
 
 std::string to_camel_case(const std::string& _str) {
   std::string result;
+  result.reserve(_str.size());
   bool capitalize = false;
   for (const char ch : _str) {
     if (ch == '_') {

tests/json/test_camel_case_to_snake_case_rename.cpp

@@ -0,0 +1,24 @@
+#include <rfl.hpp>
+#include <rfl/json.hpp>
+#include <string>
+
+#include "write_and_read.hpp"
+
+namespace test_camel_case_to_snake_case_rename {
+
+struct Person {
+  std::string firstName;
+  std::string lastName;
+  rfl::Rename<"homeTown", std::string> homeTown = "Springfield";
+};
+
+TEST(json, test_camel_case_to_snake_case_rename) {
+
+  const auto homer = Person{.firstName = "Homer", .lastName = "Simpson"};
+
+  write_and_read<rfl::CamelCaseToSnakeCase>(
+      homer,
+      R"({"first_name":"Homer","last_name":"Simpson","homeTown":"Springfield"})");
+}
+
+}  // namespace test_camel_case_to_snake_case_rename