acquisitionsetup.h

#ifndef CTL_ACQUISITIONSETUP_H
#define CTL_ACQUISITIONSETUP_H

#include "abstractpreparestep.h"
#include "simplectsystem.h"

namespace CTL {

class AcquisitionSetup final : public SerializationInterface
{
public:
    typedef std::shared_ptr<const AbstractPrepareStep> PrepareStep; 

    class View;

    AcquisitionSetup() = default;
    AcquisitionSetup(const CTSystem& system, uint nbViews = 0);
    AcquisitionSetup(CTSystem&& system, uint nbViews = 0);
    AcquisitionSetup(std::unique_ptr<CTSystem> system, uint nbViews = 0);
    AcquisitionSetup(std::unique_ptr<SimpleCTSystem> system, uint nbViews = 0);
    AcquisitionSetup(uint nbViews);

    // cp/mv cstor/assignment
    AcquisitionSetup(const AcquisitionSetup& other);
    AcquisitionSetup& operator=(const AcquisitionSetup& other);
    AcquisitionSetup(AcquisitionSetup&& other) = default;
    AcquisitionSetup& operator=(AcquisitionSetup&& other) = default;

    void addView(View view);
    void applyPreparationProtocol(const AbstractPreparationProtocol& preparation);
    bool isValid() const;
    uint nbViews() const;
    void prepareView(uint viewNb);
    void removeAllPrepareSteps(bool keepTimeStamps = true);
    void removeAllPrepareStepsOfType(int prepareStepType);
    void removeAllViews();
    bool resetSystem(const CTSystem& system);
    bool resetSystem(CTSystem&& system);
    void setNbViews(uint nbViews);
    AcquisitionSetup subset(const std::vector<uint>& viewIds) const;
    SimpleCTSystem* system();
    const SimpleCTSystem* system() const;
    View& view(uint viewNb);
    const View& view(uint viewNb) const;
    std::vector<View>& views();
    const std::vector<View>& views() const;

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

private:
    std::unique_ptr<SimpleCTSystem> _system; 
    std::vector<View> _views; 
};

class AcquisitionSetup::View : public SerializationInterface
{
public:
    // ctors
    View() = default;
    explicit View(double time);

    // time
    void setTimeStamp(double timeStamp);
    double timeStamp() const;

    // prepare steps
    void addPrepareStep(PrepareStep step);
    void clearPrepareSteps();
    size_t nbPrepareSteps() const;
    const std::vector<PrepareStep>& prepareSteps() const;
    const PrepareStep& prepareStep(int prepareStepType, bool searchFromBack = true) const;
    int indexOfPrepareStep(int prepareStepType, bool searchFromBack = true) const;
    bool hasPrepareStep(int prepareStepType) const;
    bool replacePrepareStep(int index, PrepareStep newPrepareStep);
    bool replacePrepareStep(PrepareStep newPrepareStep, bool searchFromBack = true);
    void removeAllPrepareSteps(int prepareStepType);
    void removeLastPrepareStep();
    void removePrepareStep(int prepareStepType, bool searchFromBack = true);

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

private:
    PrepareStep& prepareStep(int prepareStepType, bool searchFromBack);

    double _timeStamp; 
    std::vector<PrepareStep> _prepareSteps; 
};

} // namespace CTL

#endif // CTL_ACQUISITIONSETUP_H