jsonserializer.h

#ifndef QTJSONSERIALIZER_JSONSERIALIZER_H
#define QTJSONSERIALIZER_JSONSERIALIZER_H
 
#include "QtJsonSerializer/qtjsonserializer_global.h"
#include "QtJsonSerializer/serializerbase.h"
 
#include <QtCore/qjsonobject.h>
#include <QtCore/qjsonarray.h>
#include <QtCore/qjsondocument.h>
 
namespace QtJsonSerializer {
 
class JsonSerializerPrivate;
class Q_JSONSERIALIZER_EXPORT JsonSerializer : public SerializerBase
{
    Q_OBJECT
 
    Q_PROPERTY(ByteArrayFormat byteArrayFormat READ byteArrayFormat WRITE setByteArrayFormat NOTIFY byteArrayFormatChanged)
    Q_PROPERTY(bool validateBase64 READ validateBase64 WRITE setValidateBase64 NOTIFY validateBase64Changed)
 
public:
    enum class ByteArrayFormat {
        Base64, 
        Base64url, 
        Base16  
    };
    Q_ENUM(ByteArrayFormat)
 
    
    explicit JsonSerializer(QObject *parent = nullptr);
 
    QJsonValue serialize(const QVariant &data) const;
    void serializeTo(QIODevice *device, const QVariant &data, QJsonDocument::JsonFormat format = QJsonDocument::Compact) const;
    QByteArray serializeTo(const QVariant &data, QJsonDocument::JsonFormat format = QJsonDocument::Compact) const;
 
    template <typename T>
    typename QtJsonSerializer::__private::json_type<T>::type serialize(const T &data) const;
    template <typename T>
    void serializeTo(QIODevice *device, const T &data, QJsonDocument::JsonFormat format = QJsonDocument::Compact) const;
    template <typename T>
    QByteArray serializeTo(const T &data, QJsonDocument::JsonFormat format = QJsonDocument::Compact) const;
 
    QVariant deserialize(const QJsonValue &json, int metaTypeId, QObject *parent = nullptr) const;
    QVariant deserializeFrom(QIODevice *device, int metaTypeId, QObject *parent = nullptr) const;
    QVariant deserializeFrom(const QByteArray &data, int metaTypeId, QObject *parent = nullptr) const;
 
    template <typename T>
    T deserialize(const typename QtJsonSerializer::__private::json_type<T>::type &json, QObject *parent = nullptr) const;
    template <typename T>
    T deserializeFrom(QIODevice *device, QObject *parent = nullptr) const;
    template <typename T>
    T deserializeFrom(const QByteArray &data, QObject *parent = nullptr) const;
 
    ByteArrayFormat byteArrayFormat() const;
    bool validateBase64() const;
 
    std::variant<QCborValue, QJsonValue> serializeGeneric(const QVariant &value) const override;
    QVariant deserializeGeneric(const std::variant<QCborValue, QJsonValue> &value, int metaTypeId, QObject *parent) const override;
 
public Q_SLOTS:
    void setByteArrayFormat(ByteArrayFormat byteArrayFormat);
    void setValidateBase64(bool validateBase64);
 
Q_SIGNALS:
    void byteArrayFormatChanged(ByteArrayFormat byteArrayFormat, QPrivateSignal);
    void validateBase64Changed(bool validateBase64, QPrivateSignal);
 
protected:
    // protected implementation -> internal use for the type converters
    bool jsonMode() const override;
    QCborTag typeTag(int metaTypeId) const override;
    QList<int> typesForTag(QCborTag tag) const override;
 
private:
    Q_DECLARE_PRIVATE(JsonSerializer)
};
 
// ------------- Generic Implementation -------------
 
template<typename T>
typename QtJsonSerializer::__private::json_type<T>::type JsonSerializer::serialize(const T &data) const
{
    static_assert(__private::is_serializable<T>::value, "T cannot be serialized");
    return __private::json_type<T>::convert(serialize(__private::variant_helper<T>::toVariant(data)));
}
 
template<typename T>
void JsonSerializer::serializeTo(QIODevice *device, const T &data, QJsonDocument::JsonFormat format) const
{
    static_assert(__private::is_serializable<T>::value, "T cannot be serialized");
    serializeTo(device, __private::variant_helper<T>::toVariant(data), format);
}
 
template<typename T>
QByteArray JsonSerializer::serializeTo(const T &data, QJsonDocument::JsonFormat format) const
{
    static_assert(__private::is_serializable<T>::value, "T cannot be serialized");
    return serializeTo(__private::variant_helper<T>::toVariant(data), format);
}
 
template<typename T>
T JsonSerializer::deserialize(const typename __private::json_type<T>::type &json, QObject *parent) const
{
    static_assert(__private::is_serializable<T>::value, "T cannot be deserialized");
    return __private::variant_helper<T>::fromVariant(deserialize(json, qMetaTypeId<T>(), parent));
}
 
template<typename T>
T JsonSerializer::deserializeFrom(QIODevice *device, QObject *parent) const
{
    static_assert(__private::is_serializable<T>::value, "T cannot be deserialized");
    return __private::variant_helper<T>::fromVariant(deserializeFrom(device, qMetaTypeId<T>(), parent));
}
 
template<typename T>
T JsonSerializer::deserializeFrom(const QByteArray &data, QObject *parent) const
{
    static_assert(QtJsonSerializer::__private::is_serializable<T>::value, "T cannot be deserialized");
    return QtJsonSerializer::__private::variant_helper<T>::fromVariant(deserializeFrom(data, qMetaTypeId<T>(), parent));
}
 
}
 
#endif // QTJSONSERIALIZER_JSONSERIALIZER_H