Moved string functions to source files

include/rfl/capnproto/read.hpp

@@ -12,7 +12,7 @@
 
 #include "../Processors.hpp"
 #include "../SnakeCaseToCamelCase.hpp"
-#include "../internal/strings/to_pascal_case.hpp"
+#include "../internal/strings/strings.hpp"
 #include "../internal/wrap_in_rfl_array_t.hpp"
 #include "../parsing/make_type_name.hpp"
 #include "Parser.hpp"

include/rfl/capnproto/write.hpp

@@ -18,7 +18,7 @@
 
 #include "../SnakeCaseToCamelCase.hpp"
 #include "../internal/ptr_cast.hpp"
-#include "../internal/strings/to_pascal_case.hpp"
+#include "../internal/strings/strings.hpp"
 #include "../parsing/Parent.hpp"
 #include "../parsing/make_type_name.hpp"
 #include "Parser.hpp"

include/rfl/internal/enums/StringConverter.hpp

@@ -8,8 +8,7 @@
 #include <type_traits>
 
 #include "../../Result.hpp"
-#include "../../internal/strings/join.hpp"
-#include "../../internal/strings/split.hpp"
+#include "../../internal/strings/strings.hpp"
 #include "../../type_name_t.hpp"
 #include "get_enum_names.hpp"
 #include "is_flag_enum.hpp"

include/rfl/internal/strings/strings.hpp

@@ -0,0 +1,29 @@
+#ifndef RFL_INTERNAL_STRINGS_STRINGS_HPP_
+#define RFL_INTERNAL_STRINGS_STRINGS_HPP_
+
+#include <string>
+#include <vector>
+
+namespace rfl::internal::strings {
+
+/// Joins a series of strings.
+std::string join(const std::string& _delimiter,
+                 const std::vector<std::string>& _strings);
+
+/// Replace all occurences of _from with _to.
+std::string replace_all(const std::string& _str, const std::string& _from,
+                        const std::string& _to);
+
+/// Splits _str along _delimiter.
+std::vector<std::string> split(const std::string& _str,
+                               const std::string& _delimiter);
+
+/// Transforms the string to camel case.
+std::string to_camel_case(const std::string& _str);
+
+/// Transforms the string to pascal case.
+std::string to_pascal_case(const std::string& _str);
+
+}  // namespace rfl::internal::strings
+
+#endif

include/rfl/parsing/NamedTupleParser.hpp

@@ -20,7 +20,6 @@
 #include "../internal/no_duplicate_field_names.hpp"
 #include "../internal/nth_element_t.hpp"
 #include "../internal/ptr_cast.hpp"
-#include "../internal/strings/replace_all.hpp"
 #include "../to_view.hpp"
 #include "AreReaderAndWriter.hpp"
 #include "Parent.hpp"

include/rfl/parsing/Parser_tagged_union.hpp

@@ -8,7 +8,7 @@
 #include "../Result.hpp"
 #include "../TaggedUnion.hpp"
 #include "../always_false.hpp"
-#include "../internal/strings/join.hpp"
+#include "../internal/strings/strings.hpp"
 #include "../named_tuple_t.hpp"
 #include "Parser_base.hpp"
 #include "TaggedUnionWrapper.hpp"

include/rfl/parsing/to_single_error_message.hpp

@@ -6,7 +6,7 @@
 #include <string>
 #include <vector>
 
-#include "../internal/strings/replace_all.hpp"
+#include "../internal/strings/strings.hpp"
 
 namespace rfl::parsing {
 

src/reflectcpp.cpp

@@ -32,4 +32,5 @@ SOFTWARE.
 #include "rfl/Generic.cpp"
 #include "rfl/generic/Reader.cpp"
 #include "rfl/generic/Writer.cpp"
+#include "rfl/internal/strings/strings.cpp"
 #include "rfl/parsing/schema/Type.cpp"

src/rfl/capnproto/Type.cpp

@@ -29,7 +29,7 @@ SOFTWARE.
 #include <functional>
 #include <type_traits>
 
-#include "rfl/internal/strings/to_pascal_case.hpp"
+#include "rfl/internal/strings/strings.hpp"
 
 namespace rfl::capnproto::schema {
 

src/rfl/capnproto/to_schema.cpp

@@ -29,8 +29,7 @@ SOFTWARE.
 #include <sstream>
 
 #include "rfl/capnproto/schema/Type.hpp"
-#include "rfl/internal/strings/split.hpp"
-#include "rfl/internal/strings/to_pascal_case.hpp"
+#include "rfl/internal/strings/strings.hpp"
 #include "rfl/json.hpp"
 #include "rfl/parsing/schemaful/tuple_to_object.hpp"
 

src/rfl/internal/strings/strings.cpp

@@ -0,0 +1,84 @@
+
+namespace rfl ::internal ::strings {
+
+char to_lower(const char ch) {
+  if (ch >= 'A' && ch <= 'Z') {
+    return ch + ('a' - 'A');
+  } else {
+    return ch;
+  }
+}
+
+char to_upper(const char ch) {
+  if (ch >= 'a' && ch <= 'z') {
+    return ch + ('A' - 'a');
+  } else {
+    return ch;
+  }
+}
+
+std::string join(const std::string& _delimiter,
+                 const std::vector<std::string>& _strings) {
+  if (_strings.size() == 0) {
+    return "";
+  }
+  auto res = _strings[0];
+  for (size_t i = 1; i < _strings.size(); ++i) {
+    res += _delimiter + _strings[i];
+  }
+  return res;
+}
+
+std::string replace_all(const std::string& _str, const std::string& _from,
+                        const std::string& _to) {
+  auto str = _str;
+
+  size_t pos = 0;
+  while ((pos = str.find(_from, pos)) != std::string::npos) {
+    str.replace(pos, _from.length(), _to);
+    pos += _to.length();
+  }
+  return str;
+}
+
+std::vector<std::string> split(const std::string& _str,
+                               const std::string& _delimiter) {
+  auto str = _str;
+  size_t pos = 0;
+  std::vector<std::string> result;
+  while ((pos = str.find(_delimiter)) != std::string::npos) {
+    result.emplace_back(str.substr(0, pos));
+    str.erase(0, pos + _delimiter.length());
+  }
+  result.emplace_back(std::move(str));
+  return result;
+}
+
+std::string to_camel_case(const std::string& _str) {
+  std::string result;
+  bool capitalize = false;
+  for (const char ch : _str) {
+    if (ch == '_') {
+      capitalize = true;
+    } else if (capitalize) {
+      result.push_back(to_upper(ch));
+      capitalize = false;
+    } else {
+      result.push_back(ch);
+    }
+  }
+  if (result.size() > 0) {
+    result[0] = to_lower(result[0]);
+  }
+  return result;
+}
+
+std::string to_pascal_case(const std::string& _str) {
+  auto result = to_camel_case("_" + _str);
+  if (result.size() > 0) {
+    result[0] = to_upper(result[0]);
+  }
+  return result;
+}
+
+}  // namespace rfl::internal::strings