feat(reflect-cpp): Switched from glaze -> reflect cpp

A bug was discovered in glaze which prevented valid toml output. We have
switched to toml++ and reflect-cpp. The interface has remained the same
so this should not break any code

build-config/reflect-cpp/include/rfl/parsing/IsReader.hpp

@@ -0,0 +1,91 @@
+#ifndef RFL_PARSING_ISREADER_HPP_
+#define RFL_PARSING_ISREADER_HPP_
+
+#include <concepts>
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <string>
+#include <string_view>
+
+#include "../Result.hpp"
+#include "../internal/is_basic_type.hpp"
+#include "../internal/wrap_in_rfl_array_t.hpp"
+#include "SupportsTaggedUnions.hpp"
+#include "schemaful/IsSchemafulReader.hpp"
+
+namespace rfl {
+namespace parsing {
+
+template <class R>
+struct MockArrayReader {
+  std::optional<Error> read(typename R::InputVarType&) const {
+    return std::nullopt;
+  }
+};
+
+template <class R>
+struct MockObjectReader {
+  void read(const std::string_view&, typename R::InputVarType&) const {}
+};
+
+template <class R, class T>
+concept IsReader =
+    (SupportsTaggedUnions<R> || schemaful::IsSchemafulReader<R>) &&
+    requires(R r, std::string name,
+             std::function<std::int16_t(std::string_view)> fct,
+             MockArrayReader<R> array_reader, MockObjectReader<R> object_reader,
+             typename R::InputArrayType arr, typename R::InputObjectType obj,
+             typename R::InputVarType var, size_t idx) {
+      /// Any Reader needs to define the following:
+      ///
+      /// 1) An InputArrayType, which must be an array-like data structure.
+      /// 2) An InputObjectType, which must contain key-value pairs.
+      /// 3) An InputVarType, which must be able to represent either
+      ///    InputArrayType, InputObjectType or a basic type (bool, integral,
+      ///    floating point, std::string).
+      /// 4) A static constexpr bool has_custom_constructor, that determines
+      ///    whether the class in question as a custom constructor, which might
+      ///    be called something like from_json_obj(...).
+
+      /// Determines whether a variable is empty (the NULL type).
+      { r.is_empty(var) } -> std::same_as<bool>;
+
+      /// Iterates through an array and writes the contained vars into
+      /// an array reader.
+      { r.read_array(array_reader, arr) } -> std::same_as<std::optional<Error>>;
+
+      /// Iterates through an object and writes the key-value pairs into an
+      /// object reader. This is what we use to handle structs and named tuples,
+      /// making it a very important function.
+      {
+        r.read_object(object_reader, obj)
+      } -> std::same_as<std::optional<Error>>;
+
+      /// Transforms var to a basic type (bool, integral,
+      /// floating point, std::string)
+      {
+        r.template to_basic_type<internal::wrap_in_rfl_array_t<T>>(var)
+      } -> std::same_as<rfl::Result<internal::wrap_in_rfl_array_t<T>>>;
+
+      /// Casts var as an InputArrayType.
+      {
+        r.to_array(var)
+      } -> std::same_as<rfl::Result<typename R::InputArrayType>>;
+
+      /// Casts var as an InputObjectType.
+      {
+        r.to_object(var)
+      } -> std::same_as<rfl::Result<typename R::InputObjectType>>;
+
+      /// Uses the custom constructor, if it has been determined that T has one
+      /// (see above).
+      {
+        r.template use_custom_constructor<internal::wrap_in_rfl_array_t<T>>(var)
+      } -> std::same_as<rfl::Result<internal::wrap_in_rfl_array_t<T>>>;
+    };
+
+}  // namespace parsing
+}  // namespace rfl
+
+#endif