abstractpreparestep.h

#ifndef CTL_ABSTRACTPREPARESTEP_H
#define CTL_ABSTRACTPREPARESTEP_H

#include "io/serializationinterface.h"
#include <QDebug>
#include <memory>
#include <vector>

/*
 * NOTE: This is header only.
 */

namespace CTL {

class AcquisitionSetup;
class CTSystem;
class SimpleCTSystem;

class AbstractPrepareStep : public SerializationInterface
{
    CTL_TYPE_ID(0)

    // abstract interface
    public:virtual void prepare(SimpleCTSystem& system) const = 0;
    public:virtual bool isApplicableTo(const CTSystem& system) const = 0;

public:
    void fromVariant(const QVariant& variant) override; // de-serialization
    QVariant toVariant() const override; // serialization

    ~AbstractPrepareStep() override = default;

protected:
    AbstractPrepareStep() = default;
    AbstractPrepareStep(const AbstractPrepareStep&) = default;
    AbstractPrepareStep(AbstractPrepareStep&&) = default;
    AbstractPrepareStep& operator=(const AbstractPrepareStep&) = default;
    AbstractPrepareStep& operator=(AbstractPrepareStep&&) = default;
};

class AbstractPreparationProtocol
{
    // abstract interface
    public:virtual std::vector<std::shared_ptr<AbstractPrepareStep>>
                   prepareSteps(uint viewNb, const AcquisitionSetup& setup) const = 0;

public:
    virtual bool isApplicableTo(const AcquisitionSetup& setup) const;
    virtual ~AbstractPreparationProtocol() = default;

protected:
    AbstractPreparationProtocol() = default;
    AbstractPreparationProtocol(const AbstractPreparationProtocol&) = default;
    AbstractPreparationProtocol(AbstractPreparationProtocol&&) = default;
    AbstractPreparationProtocol& operator=(const AbstractPreparationProtocol&) = default;
    AbstractPreparationProtocol& operator=(AbstractPreparationProtocol&&) = default;
};

// placeholder, implement meaningfully in sub-classes
inline bool AbstractPreparationProtocol::isApplicableTo(const AcquisitionSetup&) const
{
    return true;
}

inline void AbstractPrepareStep::fromVariant(const QVariant &variant)
{
    auto varMap = variant.toMap();
    if(varMap.value(QStringLiteral("type-id")).toInt() != type())
    {
        qWarning() << QString(typeid(*this).name())
                + "::fromVariant: Could not construct instance! "
                  "reason: incompatible variant passed";
        return;
    }
}

inline QVariant AbstractPrepareStep::toVariant() const
{
    QVariantMap ret = SerializationInterface::toVariant().toMap();

    ret.insert(QStringLiteral("name"), typeid(*this).name());

    return ret;
}

} // namespace CTL

#endif // CTL_ABSTRACTPREPARESTEP_H