PipelineController.h

#pragma once
#include "ScopeDefines.h"
#include "BaseController.h"
#include "BaseController_p.h"

// Forward declarations
template<class T> class SynchronizedQueue;
template<class T> class ScopeMessage;
namespace scope {
    class DaqChunk;
    class DaqChunkResonance;
    class ScannerVectorFrameBasic;
    typedef std::shared_ptr<ScannerVectorFrameBasic> ScannerVectorFrameBasicPtr;
    typedef std::shared_ptr<DaqChunk> DaqChunkPtr;
    typedef std::shared_ptr<DaqChunkResonance> DaqChunkResonancePtr;
    class ScopeMultiImage;
    typedef std::shared_ptr<ScopeMultiImage> ScopeMultiImagePtr;
    class ScopeMultiImageResonanceSW;
    typedef std::shared_ptr<ScopeMultiImageResonanceSW> ScopeMultiImageResonanceSWPtr;
    namespace parameters {
        class Scope;
    }
    enum ControllerReturnStatus;
}

namespace scope {

class PipelineController
    : public BaseController<SCOPE_NAREAS> {

protected:
    class Impl;

protected:
    PipelineController(PipelineController& other);

    PipelineController& operator=(PipelineController& other);

    Impl* const Pimpl() const;

public:
    PipelineController(std::array<SynchronizedQueue<ScopeMessage<SCOPE_DAQCHUNKPTR_T>>, SCOPE_NAREAS>* const _iqueues
        , SynchronizedQueue<ScopeMessage<SCOPE_MULTIIMAGEPTR_T>>* const _squeue
        , SynchronizedQueue<ScopeMessage<SCOPE_MULTIIMAGEPTR_T>>* const _dqueue
        , const parameters::Scope& _parameters);
    
    ~PipelineController();

    void SetScannerVector(const uint32_t& _area, ScannerVectorFrameBasicPtr _sv);
};

}