DataManager.h

#ifndef _ots_DataManager_h_
#define _ots_DataManager_h_
 
#include "otsdaq/Configurable/Configurable.h"
#include "otsdaq/DataManager/CircularBuffer.h"
#include "otsdaq/FiniteStateMachine/VStateMachine.h"
#include "otsdaq/Macros/CoutMacros.h"
#include "otsdaq/MessageFacility/MessageFacility.h"
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace ots
{
class DataProcessor;
class DataProducerBase;
class DataConsumer;
class CircularBufferBase;
 
class DataManager : public Configurable, public VStateMachine
{
  public:
    DataManager(const ConfigurationTree& theXDAQContextConfigTree,
                const std::string&       supervisorConfigurationPath);
    virtual ~DataManager(void);
 
    virtual void configure(void);
    virtual void halt(void);
    virtual void pause(void);
    virtual void resume(void);
    virtual void start(std::string runNumber);
    virtual void stop(void);
 
    template<class D, class H>
    void configureBuffer(const std::string& bufferUID)
    {
        buffers_[bufferUID].buffer_ = new CircularBuffer<D, H>(bufferUID);
        buffers_[bufferUID].status_ = Initialized;
    }
 
    void registerProducer(const std::string& bufferUID,
                          DataProducerBase*  producer);  
    void registerConsumer(const std::string& bufferUID,
                          DataConsumer* consumer);  
 
    void unregisterFEProducer(const std::string& bufferID,
                              const std::string& feProducerID);
 
    void dumpStatus(std::ostream* out = (std::ostream*)&(std::cout)) const;
 
  protected:
    void destroyBuffers(void);  
    // void destroyBuffer           (const std::string& bufferUID);//!!!!!Delete all the
    void configureAllBuffers(void);
    void startAllBuffers(const std::string& runNumber);
    void stopAllBuffers(void);
    void resumeAllBuffers(void);
    void pauseAllBuffers(void);
 
    void configureBuffer(const std::string& bufferUID);
    void startBuffer(const std::string& bufferUID, std::string runNumber);
    void stopBuffer(const std::string& bufferUID);
    void resumeBuffer(const std::string& bufferUID);
    void pauseBuffer(const std::string& bufferUID);
 
    enum BufferStatus
    {
        Initialized,
        Running
    };
 
    struct Buffer
    {
        CircularBufferBase*            buffer_;
        std::vector<DataProducerBase*> producers_;
        std::vector<DataConsumer*>     consumers_;
        BufferStatus                   status_;
    };
    std::map<std::string /*dataBufferId*/,
             Buffer /*CircularBuffer:=Map of Producer to Buffer Implementations*/>
        buffers_;
 
  public:
    bool parentSupervisorHasFrontends_;  
 
    const std::map<std::string /*dataBufferId*/, Buffer>& getBuffers(void) const
    {
        return buffers_;
    }
};
 
}  // namespace ots
 
#endif