asynPortClient.h

Go to the documentation of this file.

#ifndef asynPortClient_H
#define asynPortClient_H
 
#include <stdexcept>
#include <string>
#include <map>
#include <string.h>
 
#include <epicsString.h>
 
#include <asynDriver.h>
#include <asynInt32.h>
#include <asynInt32SyncIO.h>
#include <asynUInt32Digital.h>
#include <asynUInt32DigitalSyncIO.h>
#include <asynFloat64.h>
#include <asynFloat64SyncIO.h>
#include <asynOctet.h>
#include <asynOctetSyncIO.h>
#include <asynInt8Array.h>
#include <asynInt8ArraySyncIO.h>
#include <asynInt16Array.h>
#include <asynInt16ArraySyncIO.h>
#include <asynInt32Array.h>
#include <asynInt32ArraySyncIO.h>
#include <asynFloat32Array.h>
#include <asynFloat32ArraySyncIO.h>
#include <asynFloat64Array.h>
#include <asynFloat64ArraySyncIO.h>
#include <asynGenericPointer.h>
#include <asynGenericPointerSyncIO.h>
#include <asynEnum.h>
#include <asynEnumSyncIO.h>
#include <asynOption.h>
#include <asynOptionSyncIO.h>
#include <asynCommonSyncIO.h>
#include <asynDrvUser.h>
#include <asynPortDriver.h>
 
#define DEFAULT_TIMEOUT 1.0
 
 
class ASYN_API asynParamClient {
public:
    asynParamClient(const char *portName, int addr, const char* asynInterfaceType, const char *drvInfo, double timeout);
    virtual ~asynParamClient();
    void setTimeout(double timeout)
        { timeout_ = timeout; };
    void report(FILE *fp, int details);
    char *getPortName() {
       return portName_;
    }
    char *getAsynInterfaceType()
    {
        return asynInterfaceType_;
    }
protected:
    asynUser *pasynUser_;
    asynUser *pasynUserSyncIO_;
    asynInterface *pasynInterface_;
    double timeout_;
    char *portName_;
    int addr_;
    char *asynInterfaceType_;
    char *drvInfo_;
    void *drvPvt;
    void *interruptPvt_;
};
 
 
class ASYN_API asynInt32Client : public asynParamClient {
public:
    asynInt32Client(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynInt32Type, drvInfo, timeout) {
        pInterface_ = (asynInt32 *)pasynInterface_->pinterface;
        if (pasynInt32SyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt32SyncIO->connect failed"));
    };
    asynInt32Client(const char *portName, const char *drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynInt32Type, drvInfo, timeout) {
        pInterface_ = (asynInt32 *)pasynInterface_->pinterface;
        if (pasynInt32SyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt32SyncIO->connect failed"));
    };
    virtual ~asynInt32Client() {
        if (pInterface_ && interruptPvt_)
            pInterface_->cancelInterruptUser(pasynInterface_->drvPvt, pasynUser_, interruptPvt_);
        pasynInt32SyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(epicsInt32 *value) {
        return pasynInt32SyncIO->read(pasynUserSyncIO_, value, timeout_);
    };
    virtual asynStatus write(epicsInt32 value) {
        return pasynInt32SyncIO->write(pasynUserSyncIO_, value, timeout_);
    };
    virtual asynStatus getBounds(epicsInt32 *low, epicsInt32 *high) {
        return pasynInt32SyncIO->getBounds(pasynUserSyncIO_, low, high);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackInt32 pCallback, void *userPvt=0) {
        if(interruptPvt_!=NULL) return asynError;
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                  pCallback, userPvt, &interruptPvt_);
    };
private:
    asynInt32 *pInterface_;
};
 
 
class ASYN_API asynUInt32DigitalClient : public asynParamClient {
public:
    asynUInt32DigitalClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynUInt32DigitalType, drvInfo, timeout) {
        pInterface_ = (asynUInt32Digital *)pasynInterface_->pinterface;
        if (pasynUInt32DigitalSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt32SyncIO->connect failed"));
    };
    asynUInt32DigitalClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynUInt32DigitalType, drvInfo, timeout) {
        pInterface_ = (asynUInt32Digital *)pasynInterface_->pinterface;
        if (pasynUInt32DigitalSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt32SyncIO->connect failed"));
    };
    virtual ~asynUInt32DigitalClient() {
        pasynUInt32DigitalSyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(epicsUInt32 *value, epicsUInt32 mask) {
        return pasynUInt32DigitalSyncIO->read(pasynUserSyncIO_, value, mask, timeout_);
    };
    virtual asynStatus write(epicsUInt32 value, epicsUInt32 mask){
        return pasynUInt32DigitalSyncIO->write(pasynUserSyncIO_, value, mask, timeout_);
    };
    virtual asynStatus setInterrupt(epicsUInt32 mask, interruptReason reason) {
        return pasynUInt32DigitalSyncIO->setInterrupt(pasynUserSyncIO_, mask, reason, timeout_);
    };
    virtual asynStatus clearInterrupt(epicsUInt32 mask) {
        return pasynUInt32DigitalSyncIO->clearInterrupt(pasynUserSyncIO_, mask, timeout_);
    };
    virtual asynStatus getInterrupt(epicsUInt32 *mask, interruptReason reason) {
        return pasynUInt32DigitalSyncIO->getInterrupt(pasynUserSyncIO_, mask, reason, timeout_);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackUInt32Digital pCallback, epicsUInt32 mask, void* userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                  pCallback, userPvt, mask, &interruptPvt_);
    };
private:
    asynUInt32Digital *pInterface_;
};
 
 
class ASYN_API asynFloat64Client : public asynParamClient {
public:
    asynFloat64Client(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynFloat64Type, drvInfo, timeout) {
        pInterface_ = (asynFloat64 *)pasynInterface_->pinterface;
        if (pasynFloat64SyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynFloat64SyncIO->connect failed"));
    };
    asynFloat64Client(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynFloat64Type, drvInfo, timeout) {
        pInterface_ = (asynFloat64 *)pasynInterface_->pinterface;
        if (pasynFloat64SyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynFloat64SyncIO->connect failed"));
    };
    virtual ~asynFloat64Client() {
        pasynFloat64SyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(epicsFloat64 *value) {
        return pasynFloat64SyncIO->read(pasynUserSyncIO_, value, timeout_);
    };
    virtual asynStatus write(epicsFloat64 value) {
        return pasynFloat64SyncIO->write(pasynUserSyncIO_, value, timeout_);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackFloat64 pCallback, void *userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                  pCallback, userPvt, &interruptPvt_);
    };
private:
    asynFloat64 *pInterface_;
};
 
 
class ASYN_API asynOctetClient : public asynParamClient {
public:
    asynOctetClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynOctetType, drvInfo, timeout) {
        pInterface_ = (asynOctet *)pasynInterface_->pinterface;
        if (pasynOctetSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynOctetSyncIO->connect failed"));
    };
    asynOctetClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynOctetType, drvInfo, timeout) {
        pInterface_ = (asynOctet *)pasynInterface_->pinterface;
        if (pasynOctetSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynOctetSyncIO->connect failed"));
    };
    virtual ~asynOctetClient() {
        pasynOctetSyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus write(const char *buffer, size_t bufferLen, size_t *nActual) {
        return pasynOctetSyncIO->write(pasynUserSyncIO_, buffer, bufferLen, timeout_, nActual);
    };
    virtual asynStatus write(const char *buffer) {
        size_t bufferLen = strlen(buffer);
        size_t nActual;
        return pasynOctetSyncIO->write(pasynUserSyncIO_, buffer, bufferLen, timeout_, &nActual);
    };
    virtual asynStatus read(char *buffer, size_t bufferLen, size_t *nActual, int *eomReason) {
        return pasynOctetSyncIO->read(pasynUserSyncIO_, buffer, bufferLen, timeout_, nActual, eomReason);
    };
    virtual asynStatus writeRead(const char *writeBuffer, size_t writeBufferLen, char *readBuffer, size_t readBufferLen,
                                 size_t *nBytesOut, size_t *nBytesIn, int *eomReason) {
        return pasynOctetSyncIO->writeRead(pasynUserSyncIO_, writeBuffer, writeBufferLen, readBuffer, readBufferLen,
                                           timeout_, nBytesOut, nBytesIn, eomReason);
    };
    virtual asynStatus flush() {
        return pasynOctetSyncIO->flush(pasynUserSyncIO_);
    };
    virtual asynStatus setInputEos(const char *eos, int eosLen) {
        return pasynOctetSyncIO->setInputEos(pasynUserSyncIO_, eos, eosLen);
    };
    virtual asynStatus getInputEos(char *eos, int eosSize, int *eosLen) {
        return pasynOctetSyncIO->getInputEos(pasynUserSyncIO_, eos, eosSize, eosLen);
    };
    virtual asynStatus setOutputEos(const char *eos, int eosLen) {
        return pasynOctetSyncIO->setOutputEos(pasynUserSyncIO_, eos, eosLen);
    };
    virtual asynStatus getOutputEos(char *eos, int eosSize, int *eosLen) {
        return pasynOctetSyncIO->getOutputEos(pasynUserSyncIO_, eos, eosSize, eosLen);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackOctet pCallback, void *userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                  pCallback, userPvt, &interruptPvt_);
    };
private:
    asynOctet *pInterface_;
};
 
 
class ASYN_API asynInt8ArrayClient : public asynParamClient {
public:
    asynInt8ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynInt8ArrayType, drvInfo, timeout) {
        pInterface_ = (asynInt8Array *)pasynInterface_->pinterface;
        if (pasynInt8ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt8ArraySyncIO->connect failed"));
    };
    asynInt8ArrayClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynInt8ArrayType, drvInfo, timeout) {
        pInterface_ = (asynInt8Array *)pasynInterface_->pinterface;
        if (pasynInt8ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt8ArraySyncIO->connect failed"));
    };
    virtual ~asynInt8ArrayClient() {
        pasynInt8ArraySyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(epicsInt8 *value, size_t nElements, size_t *nIn) {
        return pasynInt8ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
    };
    virtual asynStatus write(epicsInt8 *value, size_t nElements) {
        return pasynInt8ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackInt8Array pCallback, void *userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                      pCallback, userPvt, &interruptPvt_);
    };
private:
    asynInt8Array *pInterface_;
};
 
 
class ASYN_API asynInt16ArrayClient : public asynParamClient {
public:
    asynInt16ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynInt16ArrayType, drvInfo, timeout) {
        pInterface_ = (asynInt16Array *)pasynInterface_->pinterface;
        if (pasynInt16ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt16ArraySyncIO->connect failed"));
    };
    asynInt16ArrayClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynInt16ArrayType, drvInfo, timeout) {
        pInterface_ = (asynInt16Array *)pasynInterface_->pinterface;
        if (pasynInt16ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt16ArraySyncIO->connect failed"));
    };
    virtual ~asynInt16ArrayClient() {
        pasynInt16ArraySyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(epicsInt16 *value, size_t nElements, size_t *nIn) {
        return pasynInt16ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
    };
    virtual asynStatus write(epicsInt16 *value, size_t nElements) {
        return pasynInt16ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackInt16Array pCallback, void *userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                       pCallback, userPvt, &interruptPvt_);
    };
private:
    asynInt16Array *pInterface_;
};
 
 
class ASYN_API asynInt32ArrayClient : public asynParamClient {
public:
    asynInt32ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynInt32ArrayType, drvInfo, timeout) {
        pInterface_ = (asynInt32Array *)pasynInterface_->pinterface;
        if (pasynInt32ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt32ArraySyncIO->connect failed"));
    };
    asynInt32ArrayClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynInt32ArrayType, drvInfo, timeout) {
        pInterface_ = (asynInt32Array *)pasynInterface_->pinterface;
        if (pasynInt32ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynInt32ArraySyncIO->connect failed"));
    };
    virtual ~asynInt32ArrayClient() {
        pasynInt32ArraySyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(epicsInt32 *value, size_t nElements, size_t *nIn) {
        return pasynInt32ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
    };
    virtual asynStatus write(epicsInt32 *value, size_t nElements) {
        return pasynInt32ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackInt32Array pCallback, void *userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                  pCallback, userPvt, &interruptPvt_);
    };
private:
    asynInt32Array *pInterface_;
};
 
 
class ASYN_API asynFloat32ArrayClient : public asynParamClient {
public:
    asynFloat32ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynFloat32ArrayType, drvInfo, timeout) {
        pInterface_ = (asynFloat32Array *)pasynInterface_->pinterface;
        if (pasynFloat32ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynFloat64ArraySyncIO->connect failed"));
    };
    asynFloat32ArrayClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynFloat32ArrayType, drvInfo, timeout) {
        pInterface_ = (asynFloat32Array *)pasynInterface_->pinterface;
        if (pasynFloat32ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynFloat64ArraySyncIO->connect failed"));
    };
    virtual ~asynFloat32ArrayClient() {
        pasynFloat32ArraySyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(epicsFloat32 *value, size_t nElements, size_t *nIn) {
        return pasynFloat32ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
    };
    virtual asynStatus write(epicsFloat32 *value, size_t nElements) {
        return pasynFloat32ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackFloat32Array pCallback, void *userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                  pCallback, userPvt, &interruptPvt_);
    };
private:
    asynFloat32Array *pInterface_;
};
 
 
class ASYN_API asynFloat64ArrayClient : public asynParamClient {
public:
    asynFloat64ArrayClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynFloat64ArrayType, drvInfo, timeout) {
        pInterface_ = (asynFloat64Array *)pasynInterface_->pinterface;
        if (pasynFloat64ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynFloat64ArraySyncIO->connect failed"));
    };
    asynFloat64ArrayClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynFloat64ArrayType, drvInfo, timeout) {
        pInterface_ = (asynFloat64Array *)pasynInterface_->pinterface;
        if (pasynFloat64ArraySyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynFloat64ArraySyncIO->connect failed"));
    };
    virtual ~asynFloat64ArrayClient() {
        pasynFloat64ArraySyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(epicsFloat64 *value, size_t nElements, size_t *nIn) {
        return pasynFloat64ArraySyncIO->read(pasynUserSyncIO_, value, nElements, nIn, timeout_);
    };
    virtual asynStatus write(epicsFloat64 *value, size_t nElements) {
        return pasynFloat64ArraySyncIO->write(pasynUserSyncIO_, value, nElements, timeout_);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackFloat64Array pCallback, void *userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                  pCallback, userPvt, &interruptPvt_);
    };
private:
    asynFloat64Array *pInterface_;
};
 
 
class ASYN_API asynGenericPointerClient : public asynParamClient {
public:
    asynGenericPointerClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynGenericPointerType, drvInfo, timeout) {
        pInterface_ = (asynGenericPointer *)pasynInterface_->pinterface;
        if (pasynGenericPointerSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynGenericPointerSyncIO->connect failed"));
    };
    asynGenericPointerClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynGenericPointerType, drvInfo, timeout) {
        pInterface_ = (asynGenericPointer *)pasynInterface_->pinterface;
        if (pasynGenericPointerSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynGenericPointerSyncIO->connect failed"));
    };
    virtual ~asynGenericPointerClient() {
        pasynGenericPointerSyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(void *pointer) {
        return pasynGenericPointerSyncIO->read(pasynUserSyncIO_, pointer, timeout_);
    };
    virtual asynStatus write(void *pointer) {
        return pasynGenericPointerSyncIO->write(pasynUserSyncIO_, pointer, timeout_);
    };
    virtual asynStatus registerInterruptUser(interruptCallbackGenericPointer pCallback, void *userPvt=0) {
        if (!userPvt) userPvt=this;
        return pInterface_->registerInterruptUser(pasynInterface_->drvPvt, pasynUser_,
                                                  pCallback, userPvt, &interruptPvt_);
    };
private:
    asynGenericPointer *pInterface_;
};
 
 
class ASYN_API asynOptionClient : public asynParamClient {
public:
    asynOptionClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynOptionType, drvInfo, timeout) {
        pInterface_ = (asynOption *)pasynInterface_->pinterface;
        if (pasynOptionSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynOptionSyncIO->connect failed"));
    };
    asynOptionClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynOptionType, drvInfo, timeout) {
        pInterface_ = (asynOption *)pasynInterface_->pinterface;
        if (pasynOptionSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynOptionSyncIO->connect failed"));
    };
    virtual ~asynOptionClient() {
        pasynOptionSyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus getOption(const char *key, char *value, int maxChars) {
        return pasynOptionSyncIO->getOption(pasynUserSyncIO_, key, value, maxChars, timeout_);
    };
    virtual asynStatus setOption(const char *key, const char *value) {
        return pasynOptionSyncIO->setOption(pasynUserSyncIO_, key, value, timeout_);
    };
private:
    asynOption *pInterface_;
};
 
 
class ASYN_API asynEnumClient : public asynParamClient {
public:
    asynEnumClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynEnumType, drvInfo, timeout) {
        pInterface_ = (asynEnum *)pasynInterface_->pinterface;
        if (pasynEnumSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynEnumSyncIO->connect failed"));
    };
    asynEnumClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynEnumType, drvInfo, timeout) {
        pInterface_ = (asynEnum *)pasynInterface_->pinterface;
        if (pasynEnumSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynEnumSyncIO->connect failed"));
    };
    virtual ~asynEnumClient() {
        pasynEnumSyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual asynStatus read(char *strings[], int values[], int severities[], size_t nElements, size_t *nIn) {
        return pasynEnumSyncIO->read(pasynUserSyncIO_, strings, values, severities, nElements, nIn, timeout_);
    };
    virtual asynStatus write(char *strings[], int values[], int severities[], size_t nElements) {
        return pasynEnumSyncIO->write(pasynUserSyncIO_, strings, values, severities, nElements, timeout_);
    };
private:
    asynEnum *pInterface_;
};
 
 
class ASYN_API asynCommonClient : public asynParamClient {
public:
    asynCommonClient(const char *portName, int addr, const char *drvInfo, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynCommonType, drvInfo, timeout) {
        pInterface_ = (asynCommon *)pasynInterface_->pinterface;
        if (pasynCommonSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynCommonSyncIO->connect failed"));
    };
    asynCommonClient(const char *portName, const char* drvInfo, int addr=0, double timeout=DEFAULT_TIMEOUT)
    : asynParamClient(portName, addr, asynCommonType, drvInfo, timeout) {
        pInterface_ = (asynCommon *)pasynInterface_->pinterface;
        if (pasynCommonSyncIO->connect(portName, addr, &pasynUserSyncIO_, drvInfo))
            throw std::runtime_error(std::string("pasynCommonSyncIO->connect failed"));
    };
    virtual ~asynCommonClient() {
        pasynCommonSyncIO->disconnect(pasynUserSyncIO_);
    };
    virtual void report(FILE *fp, int details) {
        pasynCommonSyncIO->report(pasynUserSyncIO_, fp, details);
    };
    virtual asynStatus connect() {
        return pasynCommonSyncIO->connectDevice(pasynUserSyncIO_);
    };
    virtual asynStatus disconnect() {
        return pasynCommonSyncIO->disconnectDevice(pasynUserSyncIO_);
    };
private:
    asynCommon *pInterface_;
};
 
typedef std::map<std::string, asynParamClient*> paramMap_t;
 
class ASYN_API asynPortClient {
public:
    asynPortClient(const char *portName, double timeout=1.0);
    virtual ~asynPortClient();
    void report(FILE *fp, int details);
    asynStatus write(std::string paramName, epicsInt32 value, int addr=0);
    asynStatus read(std::string paramName, epicsInt32 *value, int addr=0);
    asynStatus write(std::string paramName, epicsFloat64 value, int addr=0);
    asynStatus read(std::string paramName, epicsFloat64 *value, int addr=0);
    asynStatus write(std::string paramName, const char *value, int addr=0);
    asynStatus read(std::string paramName, char *value, size_t bufferLen, int addr=0);
 
    asynParamClient* getParamClient(std::string paramName, int addr=0);
 
private:
    asynPortDriver *pPort_;
    paramMap_t** paramMaps_;
};
 
#endif