RunManager.h

/* -*- mode: c++ -*- */
#ifndef __DAQpp_RunManager_h__
#define __DAQpp_RunManager_h__

#include <functional>
#include <algorithm>
#include <DAQ++/DAQObject.h>
#include <DAQ++/RunCommand.h>
#include <DAQ++/Module.h>
#include <DAQ++/exception.h>
#include <DAQ++/Monitor.h>

namespace DAQpp
{

class RunManager : public DAQObject
{
private:
    static unsigned long cntr;
    RunCommand *cmd;
    Monitor *monitor;
    bool active;

    bool has_to_stop;

    int mxEvts;

    void init();

    Mutex theCondition;

protected:
    int run_number;
    int event_number;

public:
    RunManager(RunCommand *rc = 0);
    RunManager(const DAQid &, RunCommand *rc = 0);
    virtual ~RunManager();


    void set_run_number(int x)
    {
        run_number = x;
    }
    int  get_run_number() const
    {
        return run_number;
    }
    int get_event_number() const
    {
        return event_number;
    }

//---------------------------------------------------------------------
// Module handling
//---------------------------------------------------------------------
    RunCommand *operator()()
    {
        return cmd;
    }
    void addModule(Module *o);

    void deleteModule(Module *o);

    void deleteModules();

    int  countModules()
    {
        return cmd->countObservers();
    }

    static void moveModules(RunManager *from, RunManager *to);

    template <class _Function>
    _Function for_each_module(_Function __f)
    {
        return cmd->for_each_observer(__f);
    }

//---------------------------------------------------------------------
// DAQ commands
//---------------------------------------------------------------------
    void PrepareToStop(bool z)
    {
        has_to_stop = z;
    }

    bool HaveToStop() const
    {
        return has_to_stop;
    }

    bool isActive() const
    {
        return active;
    }

    void deActivate();

    void Activate();

    void set_MxEvts(int n)
    {
        mxEvts = n;
    }

    int  get_MxEvts()
    {
        return mxEvts;
    }

    virtual void PrepareForRun()
    {}


    virtual void EndOfRun()
    {}

    virtual bool CheckEndOfRun();

    virtual void GetReady();

    virtual void Start();

    virtual void Stop();

    virtual void Pause();

    virtual void Continue();

    virtual void Trigger()
    {
        cmd->send_command(RunCommand::trigger);
    }

    virtual void EndOfEvent()
    {}

    virtual void Reset();

    virtual void Acquire();

    virtual int  writeData(int size, const char *data)
    {
        return size;
    };


    Monitor *get_monitor() const
    {
        return monitor;
    }

    void set_monitor( Monitor *m)
    {
        if ( monitor )
            delete monitor;

        monitor = m;
    }

//---------------------------------------------------------------------
// Functors to operate on the list of modules
//---------------------------------------------------------------------
struct ModuleAcquire : public std::unary_function<Observer *, void>
    {
        ModuleAcquire(RunManager *m) : rm(m), ndata(0)
        {}
        void operator()( Observer *o);
        RunManager *rm;
        int ndata;
    };
};
}


#endif

---