RunState.h

/* -*- mode: c++ -*- */
#ifndef __DAQpp_RunState_h__
#define __DAQpp_RunState_h__
#include <algorithm>
#include <functional>
#include <string>
#include <set>
#include <DAQ++/GTimer.h>
#include <DAQ++/ObserverModel.h>
#include <DAQ++/exception.h>

namespace DAQpp
{
class RunStateAction
{
public:
    virtual ~RunStateAction()
    {}
    virtual void execute() = 0;
};

class RunState : public Observable, public Observer
{
private:
    void cpy(const RunState &s);
public:
    RunState();

    RunState(const RunState &s)
    {
        cpy(s);
    }

    RunState &operator=(const RunState &s)
    {
        if (this != &s) cpy(s);
        return *this;
    }

    virtual ~RunState();

    enum StatusType {
        NotDefined,   
        NotReady,     
        GettingReady, 
        Ready,        
        Starting,     
        Paused,       
        Running,      
        Stopping,     
        Stopped,      
        TimeOut,      
        last_state
    };

    const std::string &get_name() const
    {
        return name;
    }
    void set_name(const std::string &s)
    {
        name = s;
    }

    void reset();
    void start();
    void stop();
    int Ntrig() const
    {
        return ntrig;
    }
    void new_trigger()
    {
        ntrig++;
    }
    void new_writen()
    {
        nwriten++;
    }
    int Nwriten() const
    {
        return nwriten;
    }
    double eff() const;

    double rate(bool average = false) const;
    double time() const
    {
        return timer();
    }
    double  get_throughput() const
    {
        return throughput;
    }
    void reset_throughput()
    {
        throughput = 0;
    }
    void set_throughput(int x)
    {
        throughput += x;
    }

    StatusType get_status() const
    {
        return status;
    }

    bool isRunning() const
    {
        return status == Running || status == Paused;
    }

    bool isReady() const
    {
        return status == Ready;
    }

    bool isPaused() const
    {
        return status == Paused;
    }

    bool isNotReady() const
    {
        return status == NotReady;
    }

    bool isTimeout() const
    {
        return status == TimeOut;
    }

    StatusType set_status(StatusType st) ;

    void update(Observable *o, Argument *arg);

    static std::string str_state[last_state];
    static std::string const &status_str(StatusType st)
    {
        return str_state[st];
    }
private:
    std::string name;
    int ntrig;
    int nwriten;
    int throughput;
    StatusType status;
    GTimer timer;

    int ntrg0;
    double tim0;

    typedef std::set<RunStateAction *> ActionList;
    ActionList action_list;
struct executeAction : public std::unary_function<RunStateAction *, void>
    {
        executeAction()
        {}
        void operator()( RunStateAction *action )
        {
            action->execute();
        }
    };
public:
    void addAction(RunStateAction *);
    void deleteAction(RunStateAction *);
    void clearActionList();
    void executeActionList();
};
}


#endif

---