Add rfl::Deprecated, which adds deprecated and deprecationMessage to json schema fields.

Author: AndrewNolte

include/rfl/Deprecated.hpp

@@ -0,0 +1,160 @@
+#ifndef RFL_DEPRECATED_HPP_
+#define RFL_DEPRECATED_HPP_
+
+#include <algorithm>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include "Literal.hpp"
+#include "default.hpp"
+#include "internal/StringLiteral.hpp"
+
+namespace rfl {
+
+/// Used to mark a field as deprecated in the JSON schema, replacing
+/// rfl::Description for deprecated fields. Includes both a deprecation message
+/// and a description:
+///   rfl::Deprecated<"use X instead", "description of field", T>
+template <internal::StringLiteral _deprecation_message,
+          internal::StringLiteral _description, class T>
+struct Deprecated {
+  /// The underlying type.
+  using Type = T;
+
+  /// The deprecation message.
+  using DeprecationMessage = rfl::Literal<_deprecation_message>;
+
+  /// The description of the field (same role as Description::Content).
+  using Content = rfl::Literal<_description>;
+
+  using ReflectionType = Type;
+
+  Deprecated() : value_(Type()) {}
+
+  Deprecated(const Type& _value) : value_(_value) {}
+
+  Deprecated(Type&& _value) noexcept : value_(std::move(_value)) {}
+
+  Deprecated(Deprecated&& _field) noexcept = default;
+
+  Deprecated(const Deprecated& _field) = default;
+
+  template <class U>
+  Deprecated(const Deprecated<_deprecation_message, _description, U>& _field)
+      : value_(_field.get()) {}
+
+  template <class U>
+  Deprecated(Deprecated<_deprecation_message, _description, U>&& _field)
+      : value_(_field.get()) {}
+
+  template <class U, typename std::enable_if<std::is_convertible_v<U, Type>,
+                                             bool>::type = true>
+  Deprecated(const U& _value) : value_(_value) {}
+
+  template <class U, typename std::enable_if<std::is_convertible_v<U, Type>,
+                                             bool>::type = true>
+  Deprecated(U&& _value) noexcept : value_(std::forward<U>(_value)) {}
+
+  template <class U, typename std::enable_if<std::is_convertible_v<U, Type>,
+                                             bool>::type = true>
+  Deprecated(const Deprecated<_deprecation_message, _description, U>& _field)
+      : value_(_field.value()) {}
+
+  /// 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>
+  Deprecated(const Default&) : value_(Type()) {}
+
+  ~Deprecated() = default;
+
+  /// The deprecation message, for internal use.
+  constexpr static const internal::StringLiteral deprecation_message_ =
+      _deprecation_message;
+
+  /// The description, for internal use.
+  constexpr static const internal::StringLiteral description_ = _description;
+
+  /// 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.
+  Deprecated& operator=(const Deprecated& _field) = default;
+
+  /// Assigns the underlying object.
+  Deprecated& operator=(Deprecated&& _field) = default;
+
+  /// Assigns the underlying object.
+  template <class U>
+  auto& operator=(
+      const Deprecated<_deprecation_message, _description, U>& _field) {
+    value_ = _field.get();
+    return *this;
+  }
+
+  /// Assigns the underlying object.
+  template <class U>
+  auto& operator=(Deprecated<_deprecation_message, _description, U>&& _field) {
+    value_ = std::forward<T>(_field.value_);
+    return *this;
+  }
+
+  /// Returns the underlying object - necessary for the reflection to work.
+  const Type& reflection() const { return value_; }
+
+  /// 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/internal/is_deprecated.hpp

@@ -0,0 +1,29 @@
+#ifndef RFL_INTERNAL_ISDEPRECATED_HPP_
+#define RFL_INTERNAL_ISDEPRECATED_HPP_
+
+#include <type_traits>
+
+#include "../Deprecated.hpp"
+#include "StringLiteral.hpp"
+
+namespace rfl {
+namespace internal {
+
+template <class T>
+class is_deprecated;
+
+template <class T>
+class is_deprecated : public std::false_type {};
+
+template <StringLiteral _message, StringLiteral _description, class Type>
+class is_deprecated<Deprecated<_message, _description, Type>>
+    : public std::true_type {};
+
+template <class T>
+constexpr bool is_deprecated_v =
+    is_deprecated<std::remove_cvref_t<std::remove_pointer_t<T>>>::value;
+
+}  // namespace internal
+}  // namespace rfl
+
+#endif

include/rfl/json/schema/Type.hpp

@@ -5,6 +5,7 @@
 #include <optional>
 #include <string>
 
+#include "../../Flatten.hpp"
 #include "../../Literal.hpp"
 #include "../../Object.hpp"
 #include "../../Ref.hpp"
@@ -15,123 +16,130 @@ namespace rfl::json::schema {
 
 /// The JSON representation of internal::schema::Type.
 struct Type {
-  struct Boolean {
+  /// Common annotation fields shared by all schema subtypes.
+  struct Annotations {
     std::optional<std::string> description{};
+    std::optional<bool> deprecated{};
+    std::optional<std::string> deprecationMessage{};
+  };
+
+  struct Boolean {
+    rfl::Flatten<Annotations> annotations{};
     Literal<"boolean"> type{};
   };
 
   struct Integer {
     Literal<"integer"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
   };
 
   struct Number {
     Literal<"number"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
   };
 
   struct String {
     Literal<"string"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Rename<"minLength", std::optional<size_t>> minSize{};
     rfl::Rename<"maxLength", std::optional<size_t>> maxSize{};
   };
 
   using NumericType = rfl::Variant<Integer, Number>;
 
   struct AllOf {
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     std::vector<Type> allOf{};
   };
 
   struct AnyOf {
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     std::vector<Type> anyOf{};
   };
 
   struct ExclusiveMaximum {
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Variant<double, int> exclusiveMaximum{};
     std::string type{};
   };
 
   struct ExclusiveMinimum {
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Variant<double, int> exclusiveMinimum{};
     std::string type{};
   };
 
   struct FixedSizeTypedArray {
     Literal<"array"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Ref<Type> items{};
     size_t minItems{};
     size_t maxItems{};
   };
 
   struct Maximum {
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Variant<double, int> maximum{};
     std::string type{};
   };
 
   struct Minimum {
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Variant<double, int> minimum{};
     std::string type{};
   };
 
   struct Null {
     Literal<"null"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
   };
 
   struct Object {
     Literal<"object"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Object<Type> properties{};
     std::vector<std::string> required{};
     std::shared_ptr<Type> additionalProperties{};
   };
 
   struct OneOf {
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     std::vector<Type> oneOf{};
   };
 
   struct Reference {
     Rename<"$ref", std::optional<std::string>> ref{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
   };
 
   struct Regex {
     Literal<"string"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     std::string pattern{};
   };
 
   struct StringEnum {
     Literal<"string"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Rename<"enum", std::vector<std::string>> values{};
   };
 
   struct StringMap {
     Literal<"object"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Ref<Type> additionalProperties{};
   };
 
   struct Tuple {
     Literal<"array"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     std::vector<Type> prefixItems{};
     bool items = false;
   };
 
   struct TypedArray {
     Literal<"array"> type{};
-    std::optional<std::string> description{};
+    rfl::Flatten<Annotations> annotations{};
     rfl::Ref<Type> items{};
     rfl::Rename<"minItems", std::optional<size_t>> minSize{};
     rfl::Rename<"maxItems", std::optional<size_t>> maxSize{};

include/rfl/parsing/Parser_default.hpp

@@ -13,6 +13,7 @@
 #include "../internal/has_reflection_type_v.hpp"
 #include "../internal/has_reflector.hpp"
 #include "../internal/is_basic_type.hpp"
+#include "../internal/is_deprecated.hpp"
 #include "../internal/is_description.hpp"
 #include "../internal/is_literal.hpp"
 #include "../internal/is_underlying_enums_v.hpp"
@@ -127,6 +128,8 @@ struct Parser {
     if constexpr (rfl::internal::is_description_v<U>) {
       return make_description<U>(_definitions);
 
+    } else if constexpr (rfl::internal::is_deprecated_v<U>) {
+      return make_deprecated<U>(_definitions);
     } else if constexpr (std::is_class_v<U> && std::is_aggregate_v<U>) {
       return make_reference<U>(_definitions);
 
@@ -147,6 +150,18 @@ struct Parser {
   }
 
  private:
+  template <class U>
+  static schema::Type make_deprecated(
+      std::map<std::string, schema::Type>* _definitions) {
+    using Type = schema::Type;
+    return Type{Type::Deprecated{
+        .deprecation_message_ = typename U::DeprecationMessage().str(),
+        .description_ = typename U::Content().str(),
+        .type_ =
+            Ref<Type>::make(Parser<R, W, std::remove_cvref_t<typename U::Type>,
+                                   ProcessorsType>::to_schema(_definitions))}};
+  }
+
   template <class U>
   static schema::Type make_description(
       std::map<std::string, schema::Type>* _definitions) {