serializer.hpp

/* Copyright (c) 2014, The Nuria Project
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *    1. The origin of this software must not be misrepresented; you must not
 *       claim that you wrote the original software. If you use this software
 *       in a product, an acknowledgment in the product documentation would be
 *       appreciated but is not required.
 *    2. Altered source versions must be plainly marked as such, and must not be
 *       misrepresented as being the original software.
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */

#ifndef NURIA_SERIALIZER_HPP
#define NURIA_SERIALIZER_HPP

#include "essentials.hpp"
#include "metaobject.hpp"
#include <QStringList>
#include <QVariant>
#include <QObject>

namespace Nuria {

class SerializerPrivate;

class NURIA_CORE_EXPORT Serializer {
public:
    
    enum RecursionDepth {
        NoRecursion = 0,
        InfiniteRecursion = -3
    };
    
    typedef std::function< MetaObject *(const QByteArray & /* typeName */) > MetaObjectFinder;
    
    typedef std::function< void *(MetaObject * /* metaObject */, QVariantMap & /* data */) > InstanceCreator;
    
    Serializer (MetaObjectFinder metaObjectFinder = defaultMetaObjectFinder,
            InstanceCreator instanceCreator = defaultInstanceCreator);
    
    ~Serializer ();
    
    QVector< QByteArray > exclude () const;
    
    void setExclude (const QVector< QByteArray > &list);
    
    QVector< QByteArray > allowedTypes () const;
    
    void setAllowedTypes (const QVector< QByteArray > &list) const;
    
    QStringList failedFields () const;
    
    int recursionDepth () const;
    
    void setRecursionDepth (int maxDepth);
    
    void *deserialize (const QVariantMap &data, MetaObject *meta);
    
    void *deserialize (const QVariantMap &data, const QByteArray &typeName);
    
    template< typename T >
    T *deserialize (const QVariantMap &data) {
        MetaObject *meta = MetaObject::of< T > ();
        return meta ? reinterpret_cast< T * > (deserialize (data, meta)) : nullptr;
    }
    
    bool populate (void *object, MetaObject *meta, const QVariantMap &data);
    
    bool populate (void *object, const QByteArray &typeName, const QVariantMap &data);
    
    template< typename T >
    bool populate (T *object, const QVariantMap &data) {
        MetaObject *meta = MetaObject::of< T > ();
        return meta ? populate (object, meta, data) : false;
    }
    
    QVariantMap serialize (void *object, MetaObject *meta);
    
    QVariantMap serialize (void *object, const QByteArray &typeName);
    
    static MetaObject *defaultMetaObjectFinder (const QByteArray &typeName);
    
    static void *defaultInstanceCreator (MetaObject *metaObject, QVariantMap &data);
    
private:
    SerializerPrivate *d;
    
    QVariantMap serializeImpl (void *object, MetaObject *meta);
    bool populateImpl (void *object, MetaObject *meta, const QVariantMap &data);
    bool variantToField (QVariant &value, const QByteArray &targetType,
                 int targetId, int sourceId, int pointerId, bool &ignored);
    bool fieldToVariant (QVariant &value, bool &ignore);
    bool readField (void *object, Nuria::MetaField &field, QVariantMap &data);
    bool writeField (void *object, Nuria::MetaField &field, const QVariantMap &data);
};

}

#endif // NURIA_SERIALIZER_HPP