serializable.h

Go to the documentation of this file.

#ifndef REFLECTIVE_RAPIDJSON_JSON_SERIALIZABLE_H
#define REFLECTIVE_RAPIDJSON_JSON_SERIALIZABLE_H
 
#include "./reflector.h"
 
#include <rapidjson/document.h>
 
#include <string>
 
namespace ReflectiveRapidJSON {
 
template <typename Type> struct JsonSerializable {
    // RapidJSON-level API
    void push(RAPIDJSON_NAMESPACE::Value &container);
    void push(RAPIDJSON_NAMESPACE::Value &container, const char *name);
 
    // high-level API
    RAPIDJSON_NAMESPACE::StringBuffer toJson() const;
    RAPIDJSON_NAMESPACE::Document toJsonDocument() const;
    static Type fromJson(const char *json, std::size_t jsonSize, JsonDeserializationErrors *errors = nullptr);
    static Type fromJson(const char *json, JsonDeserializationErrors *errors = nullptr);
    static Type fromJson(const std::string &json, JsonDeserializationErrors *errors = nullptr);
 
    static constexpr const char *qualifiedName = "ReflectiveRapidJSON::JsonSerializable";
};
 
template <typename Type> void JsonSerializable<Type>::push(RAPIDJSON_NAMESPACE::Value &container)
{
    return JsonReflector::push<Type>(*this, container);
}
 
template <typename Type> void JsonSerializable<Type>::push(RAPIDJSON_NAMESPACE::Value &container, const char *name)
{
    return JsonReflector::push<Type>(*this, name, container);
}
 
template <typename Type> RAPIDJSON_NAMESPACE::StringBuffer JsonSerializable<Type>::toJson() const
{
    return JsonReflector::toJson<Type>(static_cast<const Type &>(*this));
}
 
template <typename Type> RAPIDJSON_NAMESPACE::Document JsonSerializable<Type>::toJsonDocument() const
{
    return JsonReflector::toJsonDocument<Type>(static_cast<const Type &>(*this));
}
 
template <typename Type> Type JsonSerializable<Type>::fromJson(const char *json, std::size_t jsonSize, JsonDeserializationErrors *errors)
{
    return JsonReflector::fromJson<Type>(json, jsonSize, errors);
}
 
template <typename Type> Type JsonSerializable<Type>::fromJson(const char *json, JsonDeserializationErrors *errors)
{
    return JsonReflector::fromJson<Type>(json, std::strlen(json), errors);
}
 
template <typename Type> Type JsonSerializable<Type>::fromJson(const std::string &json, JsonDeserializationErrors *errors)
{
    return JsonReflector::fromJson<Type>(json.data(), json.size(), errors);
}
 
template <typename Type, Traits::EnableIf<std::is_base_of<JsonSerializable<Type>, Type>> * = nullptr> JsonSerializable<Type> &as(Type &serializable)
{
    return static_cast<JsonSerializable<Type> &>(serializable);
}
 
template <typename Type, Traits::EnableIf<std::is_base_of<JsonSerializable<Type>, Type>> * = nullptr>
const JsonSerializable<Type> &as(const Type &serializable)
{
    return static_cast<const JsonSerializable<Type> &>(serializable);
}
 
#define REFLECTIVE_RAPIDJSON_MAKE_JSON_SERIALIZABLE(T)                                                                                               \
    template <> struct ReflectiveRapidJSON::AdaptedJsonSerializable<T> : Traits::Bool<true> {                                                        \
    }
 
#define REFLECTIVE_RAPIDJSON_PUSH_PRIVATE_MEMBERS(T)                                                                                                 \
    friend void ::ReflectiveRapidJSON::JsonReflector::push<T>(                                                                                       \
        const T &reflectable, ::RAPIDJSON_NAMESPACE::Value::Object &value, ::RAPIDJSON_NAMESPACE::Document::AllocatorType &allocator)
 
#define REFLECTIVE_RAPIDJSON_PULL_PRIVATE_MEMBERS(T)                                                                                                 \
    friend void ::ReflectiveRapidJSON::JsonReflector::pull<T>(T & reflectable,                                                                       \
        const ::RAPIDJSON_NAMESPACE::GenericValue<::RAPIDJSON_NAMESPACE::UTF8<char>>::ConstObject &value,                                            \
        ::ReflectiveRapidJSON::JsonDeserializationErrors *errors)
 
#define REFLECTIVE_RAPIDJSON_ENABLE_PRIVATE_MEMBERS(T)                                                                                               \
    REFLECTIVE_RAPIDJSON_PUSH_PRIVATE_MEMBERS(T);                                                                                                    \
    REFLECTIVE_RAPIDJSON_PULL_PRIVATE_MEMBERS(T)
 
} // namespace ReflectiveRapidJSON
 
#endif // REFLECTIVE_RAPIDJSON_JSON_SERIALIZABLE_H