Move some code into source files to reduce compile time; #86 (#136)

---------

Co-authored-by: Patrick Urbanke <patrick@getml.com>

Author: liuzicheng1987

CMakeLists.txt

@@ -47,7 +47,7 @@ if(REFLECTCPP_USE_BUNDLED_DEPENDENCIES)
         add_library(reflectcpp STATIC)
     endif()
 
-    target_sources(reflectcpp PRIVATE src/yyjson.c)
+    target_sources(reflectcpp PRIVATE src/reflectcpp.cpp src/yyjson.c)
     set_source_files_properties(src/yyjson.c PROPERTIES LANGUAGE CXX)
 
     target_compile_features(reflectcpp PUBLIC cxx_std_20)

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 getML
+Copyright (c) 2023-2024 Code17 GmbH 
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -18,7 +18,7 @@ Design principles for reflect-cpp include:
 - Close integration with containers from the C++ standard library
 - Close adherence to C++ idioms
 - Out-of-the-box support for JSON
-- Simple installation: If no JSON support is required, reflect-cpp is header-only. For JSON support, only a single source file needs to be compiled.
+- Simple installation
 - Simple extendability to other serialization formats
 - Simple extendability to custom classes
 
@@ -520,17 +520,14 @@ The following compilers are supported:
 - Clang 14.0 or higher
 - MSVC 17.8 (19.38) or higher
 
-### Option 1: Header-only
+### Option 1: Include source files into your own build
 
-If you **do not** need JSON support or you want to link YYJSON yourself, then reflect-cpp is header-only. Simply copy the contents of the folder `include` into your source repository or add it to your include path.
-
-### Option 2: Include source files into your own build
-
-Simply copy the contents of the folder `include` into your source repository or add it to your include path and also add `src/yyjson.c` to your source files for compilation.
+Simply copy the contents of the folder `include` into your source repository or add it to your include path and also add `src/reflectcpp.cpp` and `src/yyjson.c` to your source files for compilation.
+If you want to link to your own version of yyjson, then only copy `src/reflectcpp.cpp`.
 
 If you need support for other serialization formats like flexbuffers or XML, you should also include and link the respective libraries, as listed in the section on serialization formats.
 
-### Option 3: Compilation using cmake
+### Option 2: Compilation using cmake
 
 This will simply compile YYJSON, which is the JSON library underlying reflect-cpp. You can then include reflect-cpp in your project and link to the binary
 to get reflect-cpp with JSON support.
@@ -541,7 +538,7 @@ cmake --build build -j 4  # gcc, clang
 cmake --build build --config Release -j 4  # MSVC
 ```
 
-### Option 4: Compilation using cmake and vcpkg
+### Option 3: Compilation using cmake and vcpkg
 
 If you want serialization formats other than JSON, you can either install them manually or use vcpkg.
 
@@ -636,7 +633,7 @@ To run the tests, do the following:
 
 ### Make sure includes are relative
 
-In order for the library to be able to function header-only, we need internal includes to be relative and not depend on any externally set include directory.
+We need internal includes to be relative and not depend on any externally set include directory.
 
 That is, for example, if you are within any file in `rfl/internal`, prefer
 ```cpp

include/rfl/Generic.hpp

@@ -17,15 +17,15 @@ class Generic {
   using ReflectionType =
       std::variant<bool, int, double, std::string, Object, Array>;
 
-  Generic() : value_(false) {}
+  Generic();
 
-  Generic(Generic&& _other) noexcept = default;
+  Generic(Generic&& _other) noexcept;
 
-  Generic(const Generic& _other) = default;
+  Generic(const Generic& _other);
 
-  Generic(const ReflectionType& _value) : value_(_value) {}
+  Generic(const ReflectionType& _value);
 
-  Generic(ReflectionType&& _value) noexcept : value_(std::move(_value)) {}
+  Generic(ReflectionType&& _value) noexcept;
 
   template <class T,
             typename std::enable_if<std::is_convertible_v<T, ReflectionType>,
@@ -37,22 +37,16 @@ class Generic {
                                     bool>::type = true>
   Generic(T&& _value) noexcept : value_(std::forward<T>(_value)) {}
 
-  ~Generic() = default;
+  ~Generic();
 
   /// Returns the underlying object.
   const ReflectionType& get() const { return value_; }
 
   /// Assigns the underlying object.
-  auto& operator=(const ReflectionType& _value) {
-    value_ = _value;
-    return *this;
-  }
+  Generic& operator=(const ReflectionType& _value);
 
   /// Assigns the underlying object.
-  auto& operator=(ReflectionType&& _value) noexcept {
-    value_ = std::move(_value);
-    return *this;
-  }
+  Generic& operator=(ReflectionType&& _value) noexcept;
 
   /// Assigns the underlying object.
   template <class T,
@@ -64,81 +58,37 @@ class Generic {
   }
 
   /// Assigns the underlying object.
-  Generic& operator=(const Generic& _other) = default;
+  Generic& operator=(const Generic& _other);
 
   /// Assigns the underlying object.
-  Generic& operator=(Generic&& _other) = default;
+  Generic& operator=(Generic&& _other);
 
   /// Returns the underlying object, necessary for the serialization to work.
   const ReflectionType& reflection() const { return value_; };
 
   /// Casts the underlying value to an rfl::Generic::Array or returns an
   /// rfl::Error, if the underlying value is not an rfl::Generic::Array.
-  Result<Array> to_array() const noexcept {
-    if (const auto* ptr = std::get_if<Array>(&value_)) {
-      return *ptr;
-    } else {
-      return Error(
-          "rfl::Generic: Could not cast the underlying value to an "
-          "rfl::Generic::Array.");
-    }
-  }
+  Result<Array> to_array() const noexcept;
 
   /// Casts the underlying value to a boolean or returns an rfl::Error, if the
   /// underlying value is not a boolean.
-  Result<bool> to_bool() const noexcept {
-    if (const auto* ptr = std::get_if<bool>(&value_)) {
-      return *ptr;
-    } else {
-      return Error(
-          "rfl::Generic: Could not cast the underlying value to a boolean.");
-    }
-  }
+  Result<bool> to_bool() const noexcept;
 
   /// Casts the underlying value to a double or returns an rfl::Error, if the
   /// underlying value is not a double.
-  Result<double> to_double() const noexcept {
-    if (const auto* ptr = std::get_if<double>(&value_)) {
-      return *ptr;
-    } else {
-      return Error(
-          "rfl::Generic: Could not cast the underlying value to a double.");
-    }
-  }
+  Result<double> to_double() const noexcept;
 
   /// Casts the underlying value to an integer or returns an rfl::Error, if the
   /// underlying value is not an integer.
-  Result<int> to_int() const noexcept {
-    if (const auto* ptr = std::get_if<int>(&value_)) {
-      return *ptr;
-    } else {
-      return Error(
-          "rfl::Generic: Could not cast the underlying value to an integer.");
-    }
-  }
+  Result<int> to_int() const noexcept;
 
   /// Casts the underlying value to an rfl::Generic::Object or returns an
   /// rfl::Error, if the underlying value is not an rfl::Generic::Object.
-  Result<Object> to_object() const noexcept {
-    if (const auto* ptr = std::get_if<Object>(&value_)) {
-      return *ptr;
-    } else {
-      return Error(
-          "rfl::Generic: Could not cast the underlying value to an "
-          "rfl::Generic::Object.");
-    }
-  }
+  Result<Object> to_object() const noexcept;
 
   /// Casts the underlying value to a string or returns an rfl::Error, if the
   /// underlying value is not a string.
-  Result<std::string> to_string() const noexcept {
-    if (const auto* ptr = std::get_if<std::string>(&value_)) {
-      return *ptr;
-    } else {
-      return Error(
-          "rfl::Generic: Could not cast the underlying value to a string.");
-    }
-  }
+  Result<std::string> to_string() const noexcept;
 
  private:
   ReflectionType value_;

include/rfl/Result.hpp

@@ -4,14 +4,9 @@
 #include <array>
 #include <iostream>
 #include <optional>
-#include <ranges>
-#include <span>
 #include <stdexcept>
 #include <string>
-#include <tuple>
 #include <type_traits>
-#include <variant>
-#include <vector>
 
 #include "internal/is_array.hpp"
 #include "internal/to_std_array.hpp"

include/rfl/Size.hpp

@@ -5,7 +5,6 @@
 
 #include "Ref.hpp"
 #include "Result.hpp"
-#include "parsing/Parser.hpp"
 #include "parsing/schema/ValidationType.hpp"
 
 namespace rfl {