Support serializing std::string_view

README.md

@@ -57,7 +57,8 @@ The following table shows the mapping of supported C++ types to supported JSON t
 | `float` and `double`                                                         | number       |
 | `enum` and `enum class`                                                      | number       |
 | `std::string`                                                                | string       |
-| `const char *`                                                               | string       |
+| `std::string_view`                                                           | string/null  |
+| `const char *`                                                               | string/null  |
 | iteratable lists (`std::vector`, `std::list`, ...)                           | array        |
 | sets (`std::set`, `std::unordered_set`, `std::multiset`, ...)                | array        |
 | `std::pair`, `std::tuple`                                                    | array        |
@@ -69,7 +70,7 @@ The following table shows the mapping of supported C++ types to supported JSON t
 ### Remarks
 * Raw pointer are not supported. This prevents
   forgetting to free memory which would have to be allocated when deserializing.
-* For the same reason `const char *` strings are only supported for serialization.
+* For the same reason `const char *` and `std::string_view` are only supported for serialization.
 * Enums are (de)serialized as their underlying integer value. When deserializing, it is currently *not* checked
   whether the present integer value is a valid enumeration item.
 * The JSON type for smart pointer depends on the type the pointer refers to. It can also be `null`.

lib/json/reflector.h

@@ -169,7 +169,24 @@ inline void push(Type reflectable, RAPIDJSON_NAMESPACE::Value &value, RAPIDJSON_
 template <typename Type, Traits::EnableIf<std::is_same<Type, const char *>> * = nullptr>
 inline void push(Type reflectable, RAPIDJSON_NAMESPACE::Value &value, RAPIDJSON_NAMESPACE::Document::AllocatorType &allocator)
 {
-    value.SetString(RAPIDJSON_NAMESPACE::StringRef(reflectable), allocator);
+    if (reflectable) {
+        value.SetString(RAPIDJSON_NAMESPACE::StringRef(reflectable), allocator);
+    } else {
+        value.SetNull();
+    }
+}
+
+/*!
+ * \brief Pushes the specified C-string to the specified value.
+ */
+template <typename Type, Traits::EnableIf<std::is_same<Type, std::string_view>> * = nullptr>
+inline void push(Type reflectable, RAPIDJSON_NAMESPACE::Value &value, RAPIDJSON_NAMESPACE::Document::AllocatorType &allocator)
+{
+    if (reflectable.data()) {
+        value.SetString(RAPIDJSON_NAMESPACE::StringRef(reflectable.data(), reflectable.size()), allocator);
+    } else {
+        value.SetNull();
+    }
 }
 
 /*!
@@ -570,7 +587,8 @@ inline void pull(
  * \brief Checks whether the specified value contains a string.
  * \remarks Does not actually store the value since the ownership would not be clear (see README.md).
  */
-template <typename Type, Traits::EnableIfAny<std::is_same<Type, const char *>, std::is_same<Type, const char *const &>> * = nullptr>
+template <typename Type,
+    Traits::EnableIfAny<std::is_same<Type, const char *>, std::is_same<Type, const char *const &>, std::is_same<Type, std::string_view>> * = nullptr>
 inline void pull(Type &, const RAPIDJSON_NAMESPACE::GenericValue<RAPIDJSON_NAMESPACE::UTF8<char>> &value, JsonDeserializationErrors *errors)
 {
     if (!value.IsString()) {
@@ -1008,6 +1026,17 @@ RAPIDJSON_NAMESPACE::Document toJsonDocument(const char *reflectable)
     return document;
 }
 
+/*!
+ * \brief Serializes the specified \a reflectable which is a C-string.
+ */
+template <typename Type, Traits::EnableIf<std::is_same<Type, std::string_view>> * = nullptr>
+RAPIDJSON_NAMESPACE::Document toJsonDocument(std::string_view reflectable)
+{
+    RAPIDJSON_NAMESPACE::Document document(RAPIDJSON_NAMESPACE::kStringType);
+    document.SetString(RAPIDJSON_NAMESPACE::StringRef(reflectable.data(), reflectable.size()), document.GetAllocator());
+    return document;
+}
+
 /*!
  * \brief Serializes the specified \a reflectable which can be mapped to an array.
  */

lib/traits.h

@@ -54,14 +54,16 @@ template <typename Type>
 using IsMultiSet
     = Traits::Any<Traits::IsSpecializationOf<Type, std::multiset>, Traits::IsSpecializationOf<Type, std::unordered_multiset>, TreatAsMultiSet<Type>>;
 template <typename Type>
-using IsArrayOrSet = Traits::Any<Traits::All<Traits::IsIteratable<Type>, Traits::Not<Traits::IsSpecializationOf<Type, std::basic_string>>,
+using IsArrayOrSet = Traits::Any<
-                                     Traits::Not<IsMapOrHash<Type>>, Traits::Not<IsMultiMapOrHash<Type>>>,
+    Traits::All<Traits::IsIteratable<Type>, Traits::Not<Traits::IsSpecializationOf<Type, std::basic_string>>,
+        Traits::Not<Traits::IsSpecializationOf<Type, std::basic_string_view>>, Traits::Not<IsMapOrHash<Type>>, Traits::Not<IsMultiMapOrHash<Type>>>,
     TreatAsSet<Type>, TreatAsMultiSet<Type>>;
 template <typename Type>
 using IsArray = Traits::All<Traits::IsIteratable<Type>, Traits::Not<Traits::IsSpecializationOf<Type, std::basic_string>>,
     Traits::Not<IsMapOrHash<Type>>, Traits::Not<IsMultiMapOrHash<Type>>, Traits::Not<IsSet<Type>>, Traits::Not<IsMultiSet<Type>>>;
 template <typename Type>
-using IsIteratableExceptString = Traits::All<Traits::IsIteratable<Type>, Traits::Not<Traits::IsSpecializationOf<Type, std::basic_string>>>;
+using IsIteratableExceptString = Traits::All<Traits::IsIteratable<Type>, Traits::Not<Traits::IsSpecializationOf<Type, std::basic_string>>,
+    Traits::Not<Traits::IsSpecializationOf<Type, std::basic_string>>>;
 template <typename Type> using IsVariant = Traits::All<Traits::IsSpecializationOf<Type, std::variant>>;
 
 } // namespace ReflectiveRapidJSON