EpicsMessenger.h

Go to the documentation of this file.

#ifndef _RMS_EPICSMESSENGER_H
#define _RMS_EPICSMESSENGER_H

#include <rms/provider/ProviderListener.h>
#include <rms/provider/MessageAssembler.h>
#include <rms/provider/MessageSplitter.h>
#include <rms/provider/MessageFragment.h>
#include <rms/util/UUIDGenerator.h>

#include <cadef.h>

#include <string>
#include <vector>
#include <iostream>

/**
 * The declaration for ca_detach_context() is missing
 * from cadef.h, so we'll declare it here so we can
 * use it without modifying EPICS.
 */
void epicsShareAPI ca_detach_context();

namespace gov {

namespace fnal {

namespace cd {

namespace rms {

namespace provider {

/**
 * This class provides functionality to communicate with EPICS waveform
 * process variables.  It automatically splits up messages that are too
 * long into the necessary number of fragments and automatically assembles
 * fragments into messages on input.
 *
 * Note that this class is _NOT_ thread safe.
 *
 * @author Kurt Biery
 * @author Steve Foulkes
 * @version $Revision: 1.1.1.1 $ $Date: 2009/10/09 20:03:00 $
 */

class EpicsMessenger {
 public:  
    EpicsMessenger(std::string pvName, struct ca_client_context *caContext, 
                   int maxSize, util::UUIDGenerator *uuidGenerator);
    ~EpicsMessenger();

    std::string getName() const;
    
    void sendMessage(const std::string& messageText);

    void addListener(ProviderListener *listener);
    
    void removeListener(ProviderListener *listener);

    void monitorChanged(char *data);
    void notifyListeners(std::string messageText);

    void close();

 private:    
    /**
     * Flag to indicate the first time that a listener is added.
     */
    bool _firstListener;
  
    /**
     * The length of time (in seconds) to use when waiting for
     * pending operations to complete.
     */
    static const double _PEND_OP_TIMEOUT = 2.0;

    /**
     * The channel access context that we're using for communication.
     */
    struct ca_client_context *_caContext;
    
    /**
     * The channel that we'll use to access the process variable.
     */
    chid _pvChannel;

    /**
     * Handle to the channel subscription.
     */
    evid _pvSubscription;

    /**
     * The name of the process variable.
     */
    std::string _pvName;

    /**
     * The maximum number of bytes that we can write to an underlying
     * EPICS waveform record at one time.
     */
    int _maxMessageSize;

    /**
     * The list of listeners interested in being notified when
     * the process variable value changes.
     */
    std::vector <ProviderListener *> _listenerList;

    /**
     * The list of message assemblers that are active.
     */
    std::vector <MessageAssembler *> _assemblerList;

    /**
     * Generator UUIDs for messages
     */
    util::UUIDGenerator *_uuidGenerator;
};

};  // end of namespace provider

};  // end of namespace rms

};  // end of namespace cd

};  // end of namespace fnal

};  // end of namespace gov

#endif