ProcessVariable.h

#ifndef PROCESSVARIABLE_H_
#define PROCESSVARIABLE_H_

// epics
#include <cadef.h>

// tools
#include "tools/Guard.h"
#include "tools/ConcurrentList.h"

// storage
#include "storage/RawValue.h"
#include "storage/CtrlInfo.h"

// engine
#include "engine/Named.h"
#include "engine/ProcessVariableContext.h"
#include "engine/ProcessVariableListener.h"

class ProcessVariable : public NamedBase, public Guardable
{
public:
    ProcessVariable(ProcessVariableContext &ctx, const char *name);
    
    virtual ~ProcessVariable();

    OrderedMutex &getMutex();
    
    enum State
    {
        INIT,
        DISCONNECTED,
        GETTING_INFO,
        CONNECTED
    };
    
    State getState(Guard &guard) const;

    bool isConnected(Guard &guard) const;

    const char *getStateStr(Guard &guard) const;
    
    const char *getCAStateStr(Guard &guard) const;
    
    DbrType getDbrType(Guard &guard) const;
    
    DbrCount getDbrCount(Guard &guard) const;
    
    const CtrlInfo &getCtrlInfo(Guard &guard) const;

    void addStateListener(ProcessVariableStateListener *listener);

    void removeStateListener(ProcessVariableStateListener *listener);

    void addValueListener(ProcessVariableValueListener *listener);

    void removeValueListener(ProcessVariableValueListener *listener);

    void addListener(ProcessVariableListener *listener);

    void removeListener(ProcessVariableListener *listener);

    void start(Guard &guard);
    
    bool isRunning(Guard &guard);

    void getValue(Guard &guard);

    void subscribe(Guard &guard);

    bool isSubscribed(Guard &guard) const;

    void unsubscribe(Guard &guard);
    
    void stop(Guard &guard);
    
private:
    OrderedMutex                                 mutex;
    ProcessVariableContext                       &ctx;
    State                                        state;
    chid                                         id;
    evid                                         ev_id;
    DbrType                                      dbr_type;
    DbrCount                                     dbr_count;
    CtrlInfo                                     ctrl_info;
    size_t                                       outstanding_gets;

    ConcurrentList<ProcessVariableStateListener> state_listeners;
    ConcurrentList<ProcessVariableValueListener> value_listeners;
 
    // Channel Access callbacks   
    static void connection_handler(struct connection_handler_args arg);
    static void control_callback(struct event_handler_args arg);
    static void value_callback(struct event_handler_args);
    
    bool setup_ctrl_info(Guard &guard, DbrType type, const void *dbr_ctrl_xx);
    void firePvConnected();
    void firePvDisconnected();
    void firePvValue(const RawValue::Data *value);
};

inline bool ProcessVariable::isConnected(Guard &guard) const
{
    return getState(guard) == CONNECTED;
}

inline DbrType ProcessVariable::getDbrType(Guard &guard) const
{
    return dbr_type;
}
    
inline DbrCount ProcessVariable::getDbrCount(Guard &guard) const
{
    return dbr_count;
}

inline const CtrlInfo &ProcessVariable::getCtrlInfo(Guard &guard) const
{
    return ctrl_info;
}

inline void ProcessVariable::addStateListener(
                                       ProcessVariableStateListener *listener)
{
    state_listeners.add(listener);                              
}

inline void ProcessVariable::removeStateListener(
                                       ProcessVariableStateListener *listener)
{
    state_listeners.remove(listener);
}

inline void ProcessVariable::addValueListener(
                                       ProcessVariableValueListener *listener)
{
    value_listeners.add(listener);                              
}

inline void ProcessVariable::removeValueListener(
                                       ProcessVariableValueListener *listener)
{
    value_listeners.remove(listener);
}

inline void ProcessVariable::addListener(ProcessVariableListener *listener)
{
    addStateListener(listener);
    addValueListener(listener);
}

inline void ProcessVariable::removeListener(ProcessVariableListener *listener)
{
    removeValueListener(listener);
    removeStateListener(listener);
}

inline bool ProcessVariable::isSubscribed(Guard &guard) const
{
    return ev_id != 0;
}

#endif /*PROCESSVARIABLE_H_*/