serializationhelper.h

Go to the documentation of this file.

#ifndef CTL_SERIALIZATIONHELPER_H
#define CTL_SERIALIZATIONHELPER_H

#include <QMap>

class QVariant;

namespace CTL {

class AbstractDataModel;
class AbstractDataModel2D;
class AbstractPrepareStep;
class AbstractProjector;
class AbstractReconstructor;
class SystemComponent;
class SerializationInterface;

class SerializationHelper
{
public:
    template<class SerializableType>
    struct RegisterWithSerializationHelper
    {
        RegisterWithSerializationHelper();
    };

    // define type: pointer to function that creates CTL objects from a QVariant
    typedef SerializationInterface* (*SerializableFactoryFunction)(const QVariant&);
    typedef QMap<int, SerializableFactoryFunction> FactoryMap;

    static SerializationHelper& instance();  // singleton getter

    // maps with registered CTL type factories
    const FactoryMap& componentFactories() const;
    const FactoryMap& modelFactories() const;
    const FactoryMap& model2DFactories() const;
    const FactoryMap& prepareStepFactories() const;
    const FactoryMap& projectorFactories() const;
    const FactoryMap& reconstructorFactories() const;
    const FactoryMap& miscFactories() const;

    // functions that parse the QVariant in order to create a concrete system component, data
    // model, prepare step, or something else with SerializationInterface as base class
    static AbstractDataModel* parseDataModel(const QVariant& variant);
    static AbstractDataModel2D* parseDataModel2D(const QVariant& variant);
    static SystemComponent* parseComponent(const QVariant& variant);
    static AbstractPrepareStep* parsePrepareStep(const QVariant& variant);
    static AbstractProjector* parseProjector(const QVariant& variant);
    static AbstractReconstructor* parseReconstructor(const QVariant& variant);
    static SerializationInterface* parseMiscObject(const QVariant& variant);

private:
    // private ctor & non-copyable
    SerializationHelper() = default;
    SerializationHelper(const SerializationHelper&) = delete;
    SerializationHelper& operator=(const SerializationHelper&) = delete;

    // generic parse function that uses a specified factory map to create an object
    static SerializationInterface* parse(const QVariant& variant, const FactoryMap& factoryMap);

    // maps that map a type ID to a factory function
    FactoryMap _componentFactories;
    FactoryMap _modelFactories;
    FactoryMap _model2DFactories;
    FactoryMap _prepareStepFactories;
    FactoryMap _miscFactories;
    FactoryMap _projectorFactories;
    FactoryMap _reconstructorFactories;
};

template<class SerializableType>
SerializationHelper::RegisterWithSerializationHelper<SerializableType>::RegisterWithSerializationHelper()
{
    auto factoryFunction = [](const QVariant& variant) -> SerializationInterface*
    {
        auto a = new SerializableType();   // requires a default constructor (can also be declared private)
        a->fromVariant(variant);
        return a;
    };

    constexpr bool sysComponent = std::is_convertible<SerializableType*, SystemComponent*>::value;
    constexpr bool dataModel = std::is_convertible<SerializableType*, AbstractDataModel*>::value;
    constexpr bool dataModel2D = std::is_convertible<SerializableType*, AbstractDataModel2D*>::value;
    constexpr bool prepStep = std::is_convertible<SerializableType*, AbstractPrepareStep*>::value;
    constexpr bool projector = std::is_convertible<SerializableType*, AbstractProjector*>::value;
    constexpr bool reconstructor = std::is_convertible<SerializableType*, AbstractReconstructor*>::value;
    constexpr bool misc = std::is_convertible<SerializableType*, SerializationInterface*>::value;

    static_assert(sysComponent || dataModel || dataModel2D ||prepStep || projector || reconstructor || misc,
                  "RegisterWithSerializationHelper fails: tried a registration of an unknown type");

    auto& serializer = SerializationHelper::instance();
    if(sysComponent)
    {
        Q_ASSERT(!serializer._componentFactories.contains(SerializableType::Type));
        serializer._componentFactories.insert(SerializableType::Type, factoryFunction);
    }
    else if(dataModel)
    {
        Q_ASSERT(!serializer._modelFactories.contains(SerializableType::Type));
        serializer._modelFactories.insert(SerializableType::Type, factoryFunction);
    }
    else if(dataModel2D)
    {
        Q_ASSERT(!serializer._model2DFactories.contains(SerializableType::Type));
        serializer._model2DFactories.insert(SerializableType::Type, factoryFunction);
    }
    else if(prepStep)
    {
        Q_ASSERT(!serializer._prepareStepFactories.contains(SerializableType::Type));
        serializer._prepareStepFactories.insert(SerializableType::Type, factoryFunction);
    }
    else if(projector)
    {
        Q_ASSERT(!serializer._projectorFactories.contains(SerializableType::Type));
        serializer._projectorFactories.insert(SerializableType::Type, factoryFunction);
    }
    else if(reconstructor)
    {
        Q_ASSERT(!serializer._reconstructorFactories.contains(SerializableType::Type));
        serializer._reconstructorFactories.insert(SerializableType::Type, factoryFunction);
    }
    else if(misc)
    {
        Q_ASSERT(!serializer._miscFactories.contains(SerializableType::Type));
        serializer._miscFactories.insert(SerializableType::Type, factoryFunction);
    }
}

} // namespace CTL


#define DECLARE_SERIALIZABLE_TYPE(className_woNamespace)                                           \
    ::CTL::SerializationHelper::RegisterWithSerializationHelper<className_woNamespace>             \
    SERIALIZATION_HELPER_KNOWS_ ## className_woNamespace;

#endif // CTL_SERIALIZATIONHELPER_H