Merge branch 'main' into nulltermination

Author: liuzicheng1987

.github/workflows/linux-conan.yaml

@@ -5,6 +5,9 @@ on: [ push, pull_request ]
 jobs:
   linux:
     name: "${{ github.job }} (Conan)"
+    concurrency:
+      group: "linux-${{ github.ref }}-${{ github.job }}-conan"
+      cancel-in-progress: true
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout

.github/workflows/linux.yaml

@@ -45,6 +45,9 @@ jobs:
             compiler-version: 17
             cxx: 23  
     name: "${{ github.job }} (${{ matrix.format }}-C++${{ matrix.cxx }}-${{ matrix.compiler }}-${{ matrix.compiler-version }})"
+    concurrency:
+      group: "linux-${{ github.ref }}-${{ github.job }}-${{ matrix.format }}-C++${{ matrix.cxx }}-${{ matrix.compiler }}-${{ matrix.compiler-version }}"
+      cancel-in-progress: true
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout

.github/workflows/macos.yaml

@@ -13,6 +13,9 @@ jobs:
         os: ["macos-latest", "macos-13"]
         format: ["tests", "benchmarks"]
     name: "${{ matrix.os }} (${{ matrix.format }})"
+    concurrency:
+      group: "macos-${{ github.ref }}-${{ github.job }}-${{ matrix.os }}-${{ matrix.format }}"
+      cancel-in-progress: true
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout

.github/workflows/windows.yaml

@@ -12,6 +12,9 @@ jobs:
       matrix:
         format: ["JSON", "AVRO", "CAPNPROTO", "CBOR", "FLEXBUFFERS", "MSGPACK", "PARQUET", "TOML", "UBJSON", "XML", "YAML", "benchmarks"]
     name: "windows-msvc (${{ matrix.format }})"
+    concurrency:
+      group: "windows-${{ github.ref }}-${{ github.job }}-${{ matrix.format }}"
+      cancel-in-progress: true
     runs-on: windows-latest
     steps:
       - name: Checkout

docs/default_val.md

@@ -0,0 +1,64 @@
+# Default values (rfl::DefaultVal)
+
+The `rfl::DefaultVal<T>` wrapper allows a struct field to have a predefined default value when serializing and deserializing. When a field is declared as `rfl::DefaultVal<T>`, the library will accept input that omits that field and will populate it with the provided default (or with a default-constructed T when no explicit default is given).
+
+## Declaration and initialization
+
+You can declare a default-valued field like this:
+
+```cpp
+struct Person {
+  std::string first_name;                             // required
+  rfl::DefaultVal<std::string> last_name = "Simpson"; // has explicit default
+  rfl::DefaultVal<std::string> town;                  // default-constructed (empty string)
+};
+```
+
+DefaultVal behaves like a thin wrapper around the underlying type. You can construct and assign it from the underlying type, from other DefaultVal instances (if convertible), or assign the special token `rfl::Default` to reset it to the default-constructed value (if the type is default-constructible):
+
+```cpp
+Person p;
+p.last_name = "Smith";            // assign underlying value
+p.town = rfl::Default{};            // reset to default (empty string)
+std::string s = p.last_name.value();
+```
+
+API convenience:
+
+- .get(), .value(), operator()() — access the underlying value (const and non-const overloads).
+- set(...) — assign underlying value.
+
+## JSON behaviour
+
+When writing JSON, fields that are DefaultVal are written like normal fields using their current underlying value. When reading JSON, omitted DefaultVal fields are filled with the default value (the value assigned in the declaration, or the type's default-constructed value).
+
+Example (object fields):
+
+```cpp
+// Person from above
+const auto homer = rfl::json::read<Person>(R"({"first_name":"Homer"})").value();
+// homer.last_name == "Simpson" (declared default)
+// homer.town == "" (default-constructed)
+```
+
+Example (no field names / positional arrays):
+
+DefaultVal also works when using rfl::NoFieldNames (positional JSON arrays). Omitted positions that correspond to DefaultVal fields get their default values:
+
+```cpp
+const auto homer = rfl::json::read<Person, rfl::NoFieldNames>(R"(["Homer"])").value();
+// homer.first_name == "Homer"
+// homer.last_name == "Simpson"
+// homer.town == ""
+```
+
+## When to use
+
+Use `rfl::DefaultVal` when you want a field to be optional at the input side but still available as a value on the resulting object (no std::optional or pointer indirection). It is particularly useful for fields with sensible defaults (for example, a common last name, a default configuration value, or empty containers/strings).
+
+## Notes
+
+- The underlying type must be default-constructible to allow resetting via `rfl::Default` or when no explicit default is supplied.
+- DefaultVal preserves normal read/write semantics; other fields that are not DefaultVal remain required unless expressed as optionals or handled by processors (e.g., `rfl::DefaultIfMissing`).
+
+For more advanced control over when fields are considered missing and how defaults are applied, see the processors documentation (e.g., `rfl::DefaultIfMissing`).

docs/index.md

@@ -34,6 +34,7 @@ reflect-cpp fills an important gap in C++ development. It minimizes boilerplate
 - Simple [installation](https://rfl.getml.com/install)
 - Simple extendability to [other serialization formats](https://rfl.getml.com/supported_formats/supporting_your_own_format)
 - Simple extendability to [custom classes](https://rfl.getml.com/concepts/custom_classes)
+- Support for default-valued fields via `rfl::DefaultVal` (see [Default values](default_val.md))
 - Being one of the fastest serialization libraries in existence, as demonstrated by our [benchmarks](https://rfl.getml.com/benchmarks)
 
 

include/rfl.hpp

@@ -17,6 +17,7 @@
 #include "rfl/Box.hpp"
 #include "rfl/Bytestring.hpp"
 #include "rfl/DefaultIfMissing.hpp"
+#include "rfl/DefaultVal.hpp"
 #include "rfl/Description.hpp"
 #include "rfl/ExtraFields.hpp"
 #include "rfl/Field.hpp"

include/rfl/DefaultVal.hpp

@@ -0,0 +1,129 @@
+#ifndef RFL_DEFAULTVAL_HPP_
+#define RFL_DEFAULTVAL_HPP_
+
+#include <type_traits>
+#include <utility>
+
+#include "default.hpp"
+
+namespace rfl {
+
+template <class T>
+struct DefaultVal {
+ public:
+  using Type = std::remove_cvref_t<T>;
+
+  DefaultVal() : value_(Type()) {}
+
+  DefaultVal(const Type& _value) : value_(_value) {}
+
+  DefaultVal(Type&& _value) noexcept : value_(std::move(_value)) {}
+
+  DefaultVal(DefaultVal&& _field) noexcept = default;
+
+  DefaultVal(const DefaultVal& _field) = default;
+
+  template <class U>
+  DefaultVal(const DefaultVal<U>& _field) : value_(_field.get()) {}
+
+  template <class U>
+  DefaultVal(DefaultVal<U>&& _field) noexcept(
+      noexcept(Type(std::move(_field.value()))))
+      : value_(std::move(_field.value())) {}
+
+  template <class U>
+    requires(std::is_convertible_v<U, Type>)
+  DefaultVal(const U& _value) : value_(_value) {}
+
+  template <class U>
+    requires(std::is_convertible_v<U, Type>)
+  DefaultVal(U&& _value) noexcept : value_(std::forward<U>(_value)) {}
+
+  template <class U>
+    requires(std::is_convertible_v<U, Type>)
+  DefaultVal(const DefaultVal<U>& _field) : value_(_field.value()) {}
+
+  /// Assigns the underlying object to its default value.
+  template <class U = Type>
+    requires(std::is_default_constructible_v<U>)
+  DefaultVal(const Default&) : value_(Type()) {}
+
+  ~DefaultVal() = default;
+
+  /// Returns the underlying object.
+  const Type& get() const { return value_; }
+
+  /// Returns the underlying object.
+  Type& operator()() { return value_; }
+
+  /// Returns the underlying object.
+  const Type& operator()() const { return value_; }
+
+  /// Assigns the underlying object.
+  auto& operator=(const Type& _value) {
+    value_ = _value;
+    return *this;
+  }
+
+  /// Assigns the underlying object.
+  auto& operator=(Type&& _value) noexcept {
+    value_ = std::move(_value);
+    return *this;
+  }
+
+  /// Assigns the underlying object.
+  template <class U, typename std::enable_if<std::is_convertible_v<U, Type>,
+                                             bool>::type = true>
+  auto& operator=(const U& _value) {
+    value_ = _value;
+    return *this;
+  }
+
+  /// Assigns the underlying object to its default value.
+  template <class U = Type,
+            typename std::enable_if<std::is_default_constructible_v<U>,
+                                    bool>::type = true>
+  auto& operator=(const Default&) {
+    value_ = Type();
+    return *this;
+  }
+
+  /// Assigns the underlying object.
+  DefaultVal& operator=(const DefaultVal& _field) = default;
+
+  /// Assigns the underlying object.
+  DefaultVal& operator=(DefaultVal&& _field) = default;
+
+  /// Assigns the underlying object.
+  template <class U>
+  auto& operator=(const DefaultVal<U>& _field) {
+    value_ = _field.get();
+    return *this;
+  }
+
+  /// Assigns the underlying object.
+  template <class U>
+  auto& operator=(DefaultVal<U>&& _field) {
+    value_ = std::forward<U>(_field.value_);
+    return *this;
+  }
+
+  /// Assigns the underlying object.
+  void set(const Type& _value) { value_ = _value; }
+
+  /// Assigns the underlying object.
+  void set(Type&& _value) { value_ = std::move(_value); }
+
+  /// Returns the underlying object.
+  Type& value() { return value_; }
+
+  /// Returns the underlying object.
+  const Type& value() const { return value_; }
+
+  /// The underlying value.
+  Type value_;
+};
+
+}  // namespace rfl
+
+#endif

include/rfl/Generic.hpp

@@ -126,13 +126,23 @@ class RFL_API Generic {
   }
 
   /// Casts the underlying value to a double or returns an rfl::Error, if the
-  /// underlying value is not a double.
+  /// underlying value is not a number or the conversion would result in loss of
+  /// precision.
   Result<double> to_double() const noexcept {
     return std::visit(
         [](auto _v) -> Result<double> {
           using V = std::remove_cvref_t<decltype(_v)>;
           if constexpr (std::is_same_v<V, double>) {
             return _v;
+          } else if constexpr (std::is_same_v<V, int64_t>) {
+            auto _d = static_cast<double>(_v);
+            if (static_cast<int64_t>(_d) == _v) {
+              return _d;
+            } else {
+              return error(
+                  "rfl::Generic: Could not cast the underlying value to a "
+                  "double without loss of precision.");
+            }
           } else {
             return error(
                 "rfl::Generic: Could not cast the underlying value to a "

include/rfl/Literal.hpp

@@ -45,10 +45,6 @@ class Literal {
 
   Literal(const std::string& _str) : value_(find_value(_str).value()) {}
 
-  /// A single-field literal is special because it
-  /// can also have a default constructor.
-  template <ValueType num_fields = num_fields_,
-            typename = std::enable_if_t<num_fields <= 1>>
   Literal() : value_(0) {}
 
   ~Literal() = default;