Add operator* and non-const get() to all wrapper classes

This commit adds `operator*` (const and non-const) to all reflect-cpp wrapper classes,
including `DefaultVal`, `Field`, `Validator`, `Description`, `Rename`, `Attribute`,
`Flatten`, `Hex`, `Oct`, `Binary`, `Generic`, `Timestamp`, and `internal::Skip`.
Additionally, it ensures that these classes have non-const `.get()`, `.value()`,
and `operator()()` where appropriate, providing consistent access to the underlying value.
Documentation has also been updated to reflect these changes.

Co-authored-by: liuzicheng1987 <19538706+liuzicheng1987@users.noreply.github.com>

Author: google-labs-jules[bot]

docs/default_val.md

@@ -25,7 +25,7 @@ std::string s = p.last_name.value();
 
 API convenience:
 
-- .get(), .value(), operator()() — access the underlying value (const and non-const overloads).
+- .get(), .value(), operator()(), operator*() — access the underlying value (const and non-const overloads).
 - set(...) — assign underlying value.
 
 ## JSON behaviour

docs/flatten_structs.md

@@ -68,3 +68,6 @@ This flattens all fields into a single JSON object:
 {"firstName":"Homer","lastName":"Simpson","age":45,"salary":60000.0}
 ```
 
+## API convenience
+
+`rfl::Flatten` behaves like a thin wrapper around the underlying type. You can access the underlying value using `.get()`, `.value()`, `operator()()`, or `operator*()` (const and non-const overloads).

docs/generic.md

@@ -55,7 +55,7 @@ The resulting JSON strings looks as follows:
 
 `rfl::Generic` contains some convenience methods that allow you to handle parsed data:
 
-You can retrieve the underlying `std::variant` using `.get()`. This then allows you to handle allow possible seven cases using the [visitor pattern](https://en.cppreference.com/w/cpp/utility/variant/visit).
+You can retrieve the underlying `std::variant` using `.get()`, `.value()`, `operator()()`, or `operator*()`. This then allows you to handle all possible seven cases using the [visitor pattern](https://en.cppreference.com/w/cpp/utility/variant/visit).
 
 If you have a guess what the types of a particular field might be, you can use any of the seven convenience methods `.to_array()`, `.to_bool()`, `.to_double()`, `.to_int()`, `.to_null()`, `.to_object()`, `.to_string()`. Each
 of these methods will return an `rfl::Result<...>` with the corresponding type, if the `rfl::Generic` does indeed contain such a type.

docs/json_schema.md

@@ -139,6 +139,8 @@ const std::string json_schema = rfl::json::to_schema<Person>(rfl::json::pretty);
 }
 ```
 
+`rfl::Description` behaves like a thin wrapper around the underlying type. Much like `rfl::Field`, you can access the underlying value using `.get()`, `.value()`, `operator()()`, or `operator*()` (const and non-const overloads).
+
 You also add a description to the entire JSON schema:
 
 ```cpp

docs/named_tuple.md

@@ -107,6 +107,10 @@ person.apply([](const auto& f) {
   auto field_name = f.name();
   const auto& value = f.value();
 });
+
+### `rfl::Field` API convenience
+
+`rfl::Field` behaves like a thin wrapper around the underlying type. You can access the underlying value using `.get()`, `.value()`, `operator()()`, or `operator*()` (const and non-const overloads).
 ```
 
 ### Monadic operations: `.transform` and `.and_then`

docs/number_systems.md

@@ -25,6 +25,6 @@ This results in the following JSON:
 Note that the contained type must be integral for `rfl::Hex` and `rfl::Oct`. For `rfl::Binary`, it must be unsigned. Moreover, 
 the number of digits for `rfl::Binary` will be determined by the bitsize of the type.
 
-You can access the contained value using `.value()`, `.get()` or simply `operator()`.
+You can access the contained value using `.value()`, `.get()`, `operator()()`, or `operator*()` (const and non-const overloads).
 
 You can produce the string representation using `.str()`.

docs/rfl_skip.md

@@ -50,6 +50,7 @@ You can access the underlying value in the field `town` using any of the followi
 person.town();
 person.town.get();
 person.town.value();
+*person.town;
 ```
 
 You can assign the underlying field just like any other field:

docs/supported_formats/xml.md

@@ -137,6 +137,8 @@ This will result in the following XML string:
 
 Note that only boolean values, string values, integral values or floating point values can be represented as attributes.
 
+`rfl::Attribute` behaves like a thin wrapper around the underlying type. Much like `rfl::Field`, you can access the underlying value using `.get()`, `.value()`, `operator()()`, or `operator*()` (const and non-const overloads).
+
 There also is a special field name called `xml_content` to be used when you want a value directly inserted into the content.
 Again, only boolean values, string values, integral values or floating point values can be represented this way:
 

docs/timestamps.md

@@ -27,8 +27,7 @@ const auto person1 = Person{.birthday = "1970-01-01"};
 const auto person2 = Person{.birthday = std::tm{...}};
 ```
 
-You can access the underlying `std::tm` struct using the `.tm()` method and you can generate 
-the string representation using the `.str()` method.
+You can access the underlying `std::tm` struct using the `.tm()`, `.get()`, `.value()`, `operator()()`, or `operator*()` method (const and non-const overloads). You can generate the string representation using the `.str()` method.
 
 ```cpp
 const std::tm birthday = person1.birthday.tm();

docs/validating_numbers.md

@@ -10,7 +10,7 @@ using IntGreaterThan10 = rfl::Validator<int, rfl::Minimum<10>>;
 When you then use the type `IntGreaterThan10` inside you `rfl::Field`, the condition will be automatically
 validated.
 
-The underlying value can be retrieved using the `.value()` method.
+The underlying value can be retrieved using the `.get()`, `.value()`, `operator()()`, or `operator*()` method (const and non-const overloads).
 
 The current conditions are currently supported by reflect-cpp: