serializer.hpp

/* Copyright (c) 2014-2015, The Nuria Project
 * The NuriaProject Framework is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * The NuriaProject Framework is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with The NuriaProject Framework.
 * If not, see <http://www.gnu.org/licenses/>.
 */

#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;
        
        typedef std::function< bool(QVariant & /* variant */, int /* toType */) > ValueConverter;
        
        Serializer (MetaObjectFinder metaObjectFinder = defaultMetaObjectFinder,
                    InstanceCreator instanceCreator = defaultInstanceCreator,
                    ValueConverter valueConverter = defaultValueConverter);
        
        ~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);
        
        static bool defaultValueConverter (QVariant &variant, int toType);
        
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