SampleMechanism.h

#ifndef SAMPLEMECHANISM_H_
#define SAMPLEMECHANISM_H_

// storage
#include "storage/Index.h"

// engine
#include "engine/Named.h"
#include "engine/EngineConfig.h"
#include "engine/ProcessVariable.h"
#include "engine/DisableFilter.h"

class SampleMechanism : public ProcessVariableListener,
                        public Guardable,
                        public virtual Named {
 public:

    SampleMechanism(const EngineConfig& config,
                    ProcessVariableContext& ctx, 
                    const char* name,
                    double period,
                    ProcessVariableListener* disable_filt_listener);

    virtual ~SampleMechanism();

 public:
    
    virtual unsigned long write(Guard& guard, Index& index) = 0;

 protected:

    virtual void addEvent(Guard& guard, short severity, const epicsTime& when) = 0;

 public:

    // SampleMechanism API

    virtual std::string getInfo(Guard& guard);

    virtual void start(Guard& guard);

    virtual void stop(Guard& guard);

    virtual void addToFUX(Guard& guard, FUX::Element* doc);

 public:

    // ProcessVariableListener API

    virtual void pvConnected(ProcessVariable& pv, const epicsTime& when) = 0;
    
    void pvDisconnected(ProcessVariable& pv, const epicsTime& when);

    virtual void pvValue(ProcessVariable& pv, const RawValue::Data* data) = 0;

 public:

    // Guardable API
    
    virtual OrderedMutex& getMutex();

 public:

    // Named API
    
    virtual const std::string& getName() const;

 public:
       
    bool isRunning(Guard& guard);
    
    ProcessVariable::State getPVState();

    void disable(const epicsTime& when);
     
    void enable(const epicsTime& when);
    
 public:
    
    inline void addStateListener(ProcessVariableStateListener* listener);

    inline void removeStateListener(ProcessVariableStateListener* listener);

    inline void addValueListener(ProcessVariableValueListener* listener);

    inline void removeValueListener(ProcessVariableValueListener* listener);

 protected:

    // These have their own mutex or don't need one.
    const EngineConfig& config;
    ProcessVariable pv;
    DisableFilter disable_filter;
    
    OrderedMutex mutex;    // Mutex for the remaining data.
    bool running;
    double period;         // .. in seconds

    bool last_stamp_set;   // For catching 'back-in-time' at the
    epicsTime last_stamp;  // buffer level.
    bool have_sample_after_connection;
};

inline void 
SampleMechanism::addStateListener(ProcessVariableStateListener *listener) {
    pv.addStateListener(listener);
}

inline void 
SampleMechanism::removeStateListener(ProcessVariableStateListener *listener){
    pv.removeStateListener(listener);
}

inline void 
SampleMechanism::addValueListener(ProcessVariableValueListener* listener){
    pv.addValueListener(listener);
}

inline void 
SampleMechanism::removeValueListener(ProcessVariableValueListener* listener){
    pv.removeValueListener(listener);
}


#endif /*SAMPLEMECHANISM_H_*/