diff --git a/src/cas/RELEASE_NOTES b/src/cas/RELEASE_NOTES index 29d5ecb52..3aae1bdb0 100644 --- a/src/cas/RELEASE_NOTES +++ b/src/cas/RELEASE_NOTES @@ -199,3 +199,28 @@ Changes between epics 3.13 Beta 11 and 3.13 Beta 12 o The constructor for class casPV no longer requires a reference to the server. For backwards compatibility a reference to the server may still be supplied, but it will not be used. + +Changes after epics 3.13.1 + +**** API Change **** +o The virtual function caServer::createPV() has been deprecated in favor of the new +virtual function caServer::attachPV() which provides exactly the same functionality. +The name was changed so that the purpose of this virtual function is more clear +to server tool designers. To remain backwards compatible the virtual function +caServer::createPV() is called by the base implementation of caServer::attachPV(). +In a future release all calls to the virtual member function caServer::createPV() +will be eliminated. + +o The class pvCreateReturn has been deprecated in favor of the new class +pvAttachReturn which provides exactly the same functionality. The name was +changed so that the purpose of this class is more clear to server tool +designers. To remain backwards compatible the class pvCreateReturn derives from +public base class pvAttachReturn. In a future release the class pvCreateReturn +will be eliminated. + +o The class casAsyncPVCreateIO has been deprecated in favor of the new class +casAsyncPVAttachIO which provides exactly the same functionality. The name was +changed so that the purpose of this class is more clear to server tool +designers. To remain backwards compatible the class casAsyncPVCreateIO derives from +public base class casAsyncPVAttachIO. In a future release the class casAsyncPVCreateIO +will be eliminated. diff --git a/src/cas/build/singleThread/Makefile.Host b/src/cas/build/singleThread/Makefile.Host index 031d5374d..84d0e8661 100644 --- a/src/cas/build/singleThread/Makefile.Host +++ b/src/cas/build/singleThread/Makefile.Host @@ -34,7 +34,7 @@ LIBSRCS += casAsyncXXIO.cc LIBSRCS += casAsyncRdIOI.cc LIBSRCS += casAsyncWtIOI.cc LIBSRCS += casAsyncExIOI.cc -LIBSRCS += casAsyncPVCIOI.cc +LIBSRCS += casAsyncAtIOI.cc LIBSRCS += casEventSys.cc LIBSRCS += casMonitor.cc LIBSRCS += casMonEvent.cc diff --git a/src/cas/example/iocmonitor/monServer.cc b/src/cas/example/iocmonitor/monServer.cc index 69545e742..00d36dc03 100644 --- a/src/cas/example/iocmonitor/monServer.cc +++ b/src/cas/example/iocmonitor/monServer.cc @@ -4,6 +4,9 @@ // // $Id$ // $Log$ +// Revision 1.2 1997/05/13 14:23:02 jbk +// added comments at top +// #include #include @@ -158,7 +161,7 @@ pvExistReturn monServer::pvExistTest(const casCtx& c,const char* pvname) return pvExistReturn(S_casApp_pvNotFound); } -casPV* monServer::createPV(const casCtx& c,const char* pvname) +casPV* monServer::pvAttach(const casCtx& c,const char* pvname) { monNode* node; diff --git a/src/cas/example/iocmonitor/monServer.h b/src/cas/example/iocmonitor/monServer.h index 3b412098e..fabd9ae18 100644 --- a/src/cas/example/iocmonitor/monServer.h +++ b/src/cas/example/iocmonitor/monServer.h @@ -7,6 +7,9 @@ * * $Id$ * $Log$ + * Revision 1.2 1997/05/13 14:23:02 jbk + * added comments at top + * */ #include "casdef.h" @@ -47,7 +50,7 @@ public: // CAS virtual overloads virtual pvExistReturn pvExistTest(const casCtx& c,const char* pvname); - virtual casPV* createPV(const casCtx& c,const char* pvname); + virtual casPV* pvAttach(const casCtx& c,const char* pvname); // CAS application management functions int repeaterConnect(void); diff --git a/src/cas/example/simple/exServer.cc b/src/cas/example/simple/exServer.cc index 2a7ea257a..af4c8eddf 100644 --- a/src/cas/example/simple/exServer.cc +++ b/src/cas/example/simple/exServer.cc @@ -197,9 +197,9 @@ pvExistReturn exServer::pvExistTest } // -// exServer::createPV() +// exServer::pvAttach() // -pvCreateReturn exServer::createPV +pvAttachReturn exServer::pvAttach (const casCtx &ctx, const char *pName) { // @@ -360,10 +360,10 @@ void exAsyncCreateIO::expire() pPV = this->pvi.createPV(this->cas, aitFalse, this->scanOn); if (pPV) { - this->postIOCompletion (pvCreateReturn(*pPV)); + this->postIOCompletion (pvAttachReturn(*pPV)); } else { - this->postIOCompletion (pvCreateReturn(S_casApp_noMemory)); + this->postIOCompletion (pvAttachReturn(S_casApp_noMemory)); } } diff --git a/src/cas/example/simple/exServer.h b/src/cas/example/simple/exServer.h index 94f15c466..17f934be4 100644 --- a/src/cas/example/simple/exServer.h +++ b/src/cas/example/simple/exServer.h @@ -316,7 +316,7 @@ public: void show (unsigned level) const; pvExistReturn pvExistTest (const casCtx&, const char *pPVName); - pvCreateReturn createPV (const casCtx &ctx, const char *pPVName); + pvAttachReturn pvAttach (const casCtx &ctx, const char *pPVName); void installAliasName(pvInfo &info, const char *pAliasName); inline void removeAliasName(pvEntry &entry); @@ -538,14 +538,14 @@ private: // exAsyncCreateIO // (PV create async IO) // -class exAsyncCreateIO : public casAsyncPVCreateIO, public exOSITimer { +class exAsyncCreateIO : public casAsyncPVAttachIO, public exOSITimer { public: // // exAsyncCreateIO() // exAsyncCreateIO(pvInfo &pviIn, exServer &casIn, const casCtx &ctxIn, aitBool scanOnIn) : - casAsyncPVCreateIO(ctxIn), exOSITimer(0.00001), + casAsyncPVAttachIO(ctxIn), exOSITimer(0.00001), pvi(pviIn), cas(casIn), scanOn(scanOnIn) {} ~exAsyncCreateIO() diff --git a/src/cas/example/testdb/pvServ.cc b/src/cas/example/testdb/pvServ.cc index d0ddc4ffe..518397530 100644 --- a/src/cas/example/testdb/pvServ.cc +++ b/src/cas/example/testdb/pvServ.cc @@ -1,6 +1,9 @@ // $Id$ // $Log$ +// Revision 1.4 1997/06/25 05:56:38 jhill +// align with API changes +// // Revision 1.3 1997/06/13 09:15:47 jhill // connect proto changes // @@ -172,29 +175,29 @@ pvExistReturn serv::pvExistTest(const casCtx&,const char* pvname) return pvExistReturn(rc); } -pvCreateReturn serv::createPV(const casCtx& in,const char* pvname) +pvAttachReturn serv::pvAttach(const casCtx& in,const char* pvname) { casPV* pPV=NULL; int val; - Debug1("createPV: %s\n",pvname); + Debug1("pvAttach: %s\n",pvname); if(strncmp(pvname,prefix,prefix_len)==0) { // we may have this one, number is after underscore if(sscanf(&pvname[prefix_len+1],"%d",&val)==1) { - Debug("createPV: I am making this PV\n"); + Debug("pvAttach: I am making this PV\n"); if(val>=0 && valcreatePV(ctx, pAliasName); +} + // // caServer::registerEvent() // diff --git a/src/cas/generic/casAsyncPVCIOI.cc b/src/cas/generic/casAsyncAtIOI.cc similarity index 53% rename from src/cas/generic/casAsyncPVCIOI.cc rename to src/cas/generic/casAsyncAtIOI.cc index 872af28fa..b4898b488 100644 --- a/src/cas/generic/casAsyncPVCIOI.cc +++ b/src/cas/generic/casAsyncAtIOI.cc @@ -29,23 +29,9 @@ * * History * $Log$ - * Revision 1.2 1997/06/13 09:15:54 jhill - * connect proto changes - * - * Revision 1.1 1997/04/10 19:38:14 jhill - * installed - * - * Revision 1.2 1996/11/06 22:15:53 jhill - * allow monitor init read to using rd async io - * - * Revision 1.1 1996/11/02 01:01:02 jhill - * installed - * - * * */ - #include "server.h" #include "casAsyncIOIIL.h" // casAsyncIOI in line func #include "casChannelIIL.h" // casChannelI in line func @@ -53,54 +39,54 @@ #include "casCoreClientIL.h" // casCoreClient in line func // -// casAsyncPVCIOI::casAsyncPVCIOI() +// casAsyncAtIOI::casAsyncAtIOI() // -epicsShareFunc casAsyncPVCIOI::casAsyncPVCIOI(const casCtx &ctx, - casAsyncPVCreateIO &ioIn) : - casAsyncIOI(*ctx.getClient(), ioIn), - msg(*ctx.getMsg()), - retVal(S_cas_badParameter) +epicsShareFunc casAsyncAtIOI::casAsyncAtIOI (const casCtx &ctx, + casAsyncPVAttachIO &ioIn) : + casAsyncIOI (*ctx.getClient(), ioIn), + msg (*ctx.getMsg()), + retVal (S_cas_badParameter) { assert (&this->msg); - this->client.installAsyncIO(*this); + this->client.installAsyncIO (*this); } // -// casAsyncPVCIOI::~casAsyncPVCIOI() +// casAsyncAtIOI::~casAsyncAtIOI() // -casAsyncPVCIOI::~casAsyncPVCIOI() +casAsyncAtIOI::~casAsyncAtIOI() { - this->client.removeAsyncIO(*this); + this->client.removeAsyncIO (*this); } // -// casAsyncPVCIOI::postIOCompletion() +// casAsyncAtIOI::postIOCompletion() // -epicsShareFunc caStatus casAsyncPVCIOI::postIOCompletion(const pvCreateReturn &retValIn) +epicsShareFunc caStatus casAsyncAtIOI::postIOCompletion(const pvAttachReturn &retValIn) { this->retVal = retValIn; - return this->postIOCompletionI(); + return this->postIOCompletionI (); } // -// casAsyncPVCIOI::cbFuncAsyncIO() +// casAsyncAtIOI::cbFuncAsyncIO() // (called when IO completion event reaches top of event queue) // -caStatus casAsyncPVCIOI::cbFuncAsyncIO() +caStatus casAsyncAtIOI::cbFuncAsyncIO() { caStatus status; - switch (this->msg.m_cmmd) { - case CA_PROTO_CLAIM_CIU: - status = this->client.createChanResponse(this->msg, this->retVal); - break; - - default: - this->reportInvalidAsynchIO(this->msg.m_cmmd); - status = S_cas_internal; - break; - } + switch (this->msg.m_cmmd) { + case CA_PROTO_CLAIM_CIU: + status = this->client.createChanResponse (this->msg, this->retVal); + break; + + default: + this->reportInvalidAsynchIO (this->msg.m_cmmd); + status = S_cas_internal; + break; + } return status; } diff --git a/src/cas/generic/casAsyncXXIO.cc b/src/cas/generic/casAsyncXXIO.cc index 1e03bb1af..f8516763e 100644 --- a/src/cas/generic/casAsyncXXIO.cc +++ b/src/cas/generic/casAsyncXXIO.cc @@ -29,6 +29,9 @@ * * History * $Log$ + * Revision 1.4 1998/02/05 22:51:34 jhill + * include resourceLib.h + * * Revision 1.3 1997/08/05 00:47:02 jhill * fixed warnings * @@ -88,3 +91,10 @@ epicsShareFunc casAsyncPVCreateIO::~casAsyncPVCreateIO() { } +// +// This must be virtual so that derived destructor will +// be run indirectly. Therefore it cannot be inline. +// +epicsShareFunc casAsyncPVAttachIO::~casAsyncPVAttachIO() +{ +} \ No newline at end of file diff --git a/src/cas/generic/casCoreClient.cc b/src/cas/generic/casCoreClient.cc index 3c68be21e..e625af5f4 100644 --- a/src/cas/generic/casCoreClient.cc +++ b/src/cas/generic/casCoreClient.cc @@ -29,6 +29,11 @@ * * History * $Log$ + * Revision 1.10 1998/10/28 23:51:00 jhill + * server nolonger throws exception when a poorly formed get/put call back + * request arrives. Instead a get/put call back response is sent which includes + * unsuccessful status + * * Revision 1.9 1998/07/08 15:38:04 jhill * fixed lost monitors during flow control problem * @@ -153,7 +158,7 @@ caStatus casCoreClient::asyncSearchResponse(casDGIntfIO &, { return S_casApp_noSupport; } -caStatus casCoreClient::createChanResponse(const caHdr &, const pvCreateReturn &) +caStatus casCoreClient::createChanResponse(const caHdr &, const pvAttachReturn &) { return S_casApp_noSupport; } diff --git a/src/cas/generic/casDGClient.cc b/src/cas/generic/casDGClient.cc index 78079fc21..4e4d31fcb 100644 --- a/src/cas/generic/casDGClient.cc +++ b/src/cas/generic/casDGClient.cc @@ -29,6 +29,9 @@ * * History * $Log$ + * Revision 1.15 1998/04/20 18:11:01 jhill + * better debug mesg + * * Revision 1.14 1998/04/10 23:13:14 jhill * fixed byte swap problems, and use default port if server tool returns PV IP addr, but no port * @@ -164,7 +167,7 @@ caStatus casDGClient::searchAction() // monitor prior to calling PV exist test so that when // the server runs out of memory we dont reply to // search requests, and therefore dont thrash through - // caServer::pvExistTest() and casCreatePV::createPV() + // caServer::pvExistTest() and casCreatePV::pvAttach() // #ifdef vxWorks # error code needs to be implemented here when we port diff --git a/src/cas/generic/casInternal.h b/src/cas/generic/casInternal.h index 91a7c3db7..752af2667 100644 --- a/src/cas/generic/casInternal.h +++ b/src/cas/generic/casInternal.h @@ -29,6 +29,9 @@ * * History * $Log$ + * Revision 1.18 1998/11/18 18:52:49 jhill + * fixed casChannelI undefined symbols on WIN32 + * * Revision 1.17 1998/10/23 00:28:20 jhill * fixed HP-UX warnings * @@ -278,7 +281,7 @@ class casAsyncIO; class casAsyncReadIO; class casAsyncWriteIO; class casAsyncPVExistIO; -class casAsyncPVCreateIO; +class casAsyncPVAttachIO; class casAsyncIOI : public casEvent, public tsDLNode { public: @@ -376,7 +379,7 @@ class casDGIntfIO; // // casAsyncExIOI // -// (server internal asynchronous read IO class) +// (server internal asynchronous PV exist test IO class) // class casAsyncExIOI : public casAsyncIOI { public: @@ -398,25 +401,25 @@ private: }; // -// casAsyncPVCIOI +// casAsyncAtIOI // -// (server internal asynchronous read IO class) +// (server internal asynchronous PV attach IO class) // -class casAsyncPVCIOI : public casAsyncIOI { +class casAsyncAtIOI : public casAsyncIOI { public: - epicsShareFunc casAsyncPVCIOI(const casCtx &ctx, casAsyncPVCreateIO &ioIn); - virtual ~casAsyncPVCIOI(); + epicsShareFunc casAsyncAtIOI(const casCtx &ctx, casAsyncPVAttachIO &ioIn); + virtual ~casAsyncAtIOI(); // // place notification of IO completion on the event queue // - epicsShareFunc caStatus postIOCompletion(const pvCreateReturn &retVal); + epicsShareFunc caStatus postIOCompletion(const pvAttachReturn &retVal); epicsShareFunc caStatus cbFuncAsyncIO(); casAsyncIO &getAsyncIO(); private: caHdr const msg; - pvCreateReturn retVal; + pvAttachReturn retVal; }; class casChannel; diff --git a/src/cas/generic/casStrmClient.cc b/src/cas/generic/casStrmClient.cc index d108107be..d3eea26cf 100644 --- a/src/cas/generic/casStrmClient.cc +++ b/src/cas/generic/casStrmClient.cc @@ -29,6 +29,11 @@ * * History * $Log$ + * Revision 1.26 1998/10/28 23:51:01 jhill + * server nolonger throws exception when a poorly formed get/put call back + * request arrives. Instead a get/put call back response is sent which includes + * unsuccessful status + * * Revision 1.25 1998/09/24 20:40:07 jhill * o block if unable to get buffer space for the exception message * o subtle changes related to properly dealing with situations where @@ -962,10 +967,11 @@ caStatus casStrmClient::clientNameAction() */ caStatus casStrmClient::claimChannelAction() { - const caHdr *mp = this->ctx.getMsg(); - char *pName = (char *) this->ctx.getData(); - unsigned nameLength; - caStatus status; + const caHdr *mp = this->ctx.getMsg(); + char *pName = (char *) this->ctx.getData(); + caServerI &cas = *this->ctx.getServer(); + unsigned nameLength; + caStatus status; /* * The available field is used (abused) @@ -994,7 +1000,6 @@ caStatus casStrmClient::claimChannelAction() return S_cas_badProtocol; // disconnect client } - if (mp->m_postsize == 0u) { return S_cas_badProtocol; // disconnect client } @@ -1014,8 +1019,12 @@ caStatus casStrmClient::claimChannelAction() // this->osiLock(); this->asyncIOFlag = 0u; - const pvCreateReturn pvcr = - (*this->ctx.getServer())->createPV (this->ctx, pName); + + // + // attach to the PV + // + pvAttachReturn pvar = cas->pvAttach (this->ctx, pName); + // // prevent problems when they initiate // async IO but dont return status @@ -1024,18 +1033,17 @@ caStatus casStrmClient::claimChannelAction() if (this->asyncIOFlag) { status = S_cas_success; } - else if (pvcr.getStatus() == S_casApp_asyncCompletion) { - status = this->createChanResponse(*mp, - pvCreateReturn(S_cas_badParameter)); + else if (pvar.getStatus() == S_casApp_asyncCompletion) { + status = this->createChanResponse(*mp, S_cas_badParameter); errMessage(S_cas_badParameter, - "- expected asynch IO creation from caServer::createPV()"); + "- expected asynch IO creation from caServer::pvAttach()"); } - else if (pvcr.getStatus() == S_casApp_postponeAsyncIO) { + else if (pvar.getStatus() == S_casApp_postponeAsyncIO) { status = S_casApp_postponeAsyncIO; this->ctx.getServer()->addItemToIOBLockedList(*this); } else { - status = this->createChanResponse(*mp, pvcr); + status = this->createChanResponse(*mp, pvar); } this->osiUnlock(); return status; @@ -1046,7 +1054,7 @@ caStatus casStrmClient::claimChannelAction() // // LOCK must be applied // -caStatus casStrmClient::createChanResponse(const caHdr &hdr, const pvCreateReturn &pvcr) +caStatus casStrmClient::createChanResponse(const caHdr &hdr, const pvAttachReturn &pvar) { casPVI *pPV; casChannel *pChan; @@ -1056,11 +1064,11 @@ caStatus casStrmClient::createChanResponse(const caHdr &hdr, const pvCreateRetur unsigned dbrType; caStatus status; - if (pvcr.getStatus() != S_cas_success) { - return this->channelCreateFailed(&hdr, pvcr.getStatus()); + if (pvar.getStatus() != S_cas_success) { + return this->channelCreateFailed(&hdr, pvar.getStatus()); } - pPV = pvcr.getPV(); + pPV = pvar.getPV(); // // If status is ok and the PV isnt set then guess that the @@ -1096,7 +1104,7 @@ caStatus casStrmClient::createChanResponse(const caHdr &hdr, const pvCreateRetur pChan = (*pPV)->createChannel(this->ctx, this->pUserName, this->pHostName); if (!pChan) { - pvcr.getPV()->deleteSignal(); + pvar.getPV()->deleteSignal(); return this->channelCreateFailed(&hdr, S_cas_noMemory); } @@ -1175,7 +1183,7 @@ caStatus createStatus) if (createStatus == S_casApp_asyncCompletion) { errMessage(S_cas_badParameter, - "- no asynchronous IO create in createPV() ?"); + "- no asynchronous IO create in pvAttach() ?"); errMessage(S_cas_badParameter, "- or S_casApp_asyncCompletion was async IO competion code ?"); } diff --git a/src/cas/generic/casdef.h b/src/cas/generic/casdef.h index bd08bf551..2484063b5 100644 --- a/src/cas/generic/casdef.h +++ b/src/cas/generic/casdef.h @@ -30,6 +30,9 @@ * Modification Log: * ----------------- * $Log$ + * Revision 1.21 1998/12/07 23:21:53 jhill + * doc + * * Revision 1.20 1998/09/24 20:40:56 jhill * new error message * @@ -252,14 +255,41 @@ private: class casPV; -class epicsShareClass pvCreateReturn { +// +// pvAttachReturn +// +class epicsShareClass pvAttachReturn { public: - pvCreateReturn(caStatus statIn) - { this->pPV = NULL; this->stat = statIn; } - pvCreateReturn(casPV &pv) - { this->pPV = &pv; this->stat = S_casApp_success; } + pvAttachReturn () + { + this->pPV = NULL; + // + // A pv name is required for success + // + this->stat = S_cas_badParameter; + } - const pvCreateReturn &operator = (caStatus rhs) + pvAttachReturn (caStatus statIn) + { + this->pPV = NULL; + if (statIn==S_casApp_success) { + // + // A pv name is required for success + // + this->stat = S_cas_badParameter; + } + else { + this->stat = statIn; + } + } + + pvAttachReturn (casPV &pv) + { + this->pPV = &pv; + this->stat = S_casApp_success; + } + + const pvAttachReturn &operator = (caStatus rhs) { this->pPV = NULL; if (rhs == S_casApp_success) { @@ -272,7 +302,7 @@ public: } // - // const pvCreateReturn &operator = (casPV &pvIn) + // const pvAttachReturn &operator = (casPV &pvIn) // // The above assignement operator is not included // because it does not match the strict definition of an @@ -281,7 +311,7 @@ public: // pointer here because the server library _will_ make // controlled modification of the PV in the future. // - const pvCreateReturn &operator = (casPV *pPVIn) + const pvAttachReturn &operator = (casPV *pPVIn) { if (pPVIn!=NULL) { this->stat = S_casApp_success; @@ -300,6 +330,16 @@ private: caStatus stat; }; +// +// pvCreateReturn (depricated) +// (the class "pvCreateReturn" will be deleted in a future release) +// +class epicsShareClass pvCreateReturn : public pvAttachReturn { +public: + pvCreateReturn (caStatus statIn) : pvAttachReturn(statIn) {}; + pvCreateReturn (casPV &pvIn) : pvAttachReturn (pvIn) {}; +}; + #include "casEventMask.h" // EPICS event select class #include "casInternal.h" // CA server private @@ -363,24 +403,27 @@ public: const char *pPVAliasName); // - // createPV() + // pvAttach() // - // This function is called _every_ time that a PV is attached to - // by a client. The name supplied here will be either a canonical PV - // name or an alias PV name. + // This function is called _every_ time that a client attaches to the PV. + // The name supplied here will be either a canonical PV name or an alias + // PV name. // // The request is allowed to complete asynchronously // (see Asynchronous IO Classes below). // // IMPORTANT: - // It is a responsibility of the server tool - // to detect attempts by the server lib to create a 2nd PV with - // the same name as an existing PV. It is also the responsibility - // of the server tool to detect attempts by the server lib to - // create a 2nd PV with a name that is an alias of an existing PV. - // In these situations the server tool should avoid PV duplication - // by returning a pointer to an existing PV (and not create a new - // PV). + // It is a responsibility of the server tool to detect attempts by + // the server library to attach to an existing PV. If the PV does not + // exist then the server tool should create it. Otherwise, the server + // tool should return a pointer to the preexisting PV. + // + // The server tool is encouraged to accept multiple PV name aliases + // for the same PV here. + // + // In all situations the server tool should avoid PV duplication + // by returning a pointer to an existing PV if the PV alias name + // matches a preexisting PV's name or any of its aliases. // // example return from this procedure: // return pPV; // success (pass by pointer) @@ -395,7 +438,7 @@ public: // asynchronous IO operation (create or exist) completes // against the server. // - epicsShareFunc virtual pvCreateReturn createPV (const casCtx &ctx, + epicsShareFunc virtual pvAttachReturn pvAttach (const casCtx &ctx, const char *pPVAliasName); // @@ -411,6 +454,15 @@ public: // caServer to a caServerI // friend class casPVI; + + // + // createPV() (deprecated) + // The virtual member function "createPV" will be deleted in a + // future release. The base implementation of pvAttach() currently + // calls createPV(). + // + epicsShareFunc virtual pvCreateReturn createPV (const casCtx &ctx, + const char *pPVAliasName); }; // @@ -711,7 +763,7 @@ public: // Virtual Function Asynchronous IO Class // ----------------- --------------------- // caServer::pvExistTest() casAsyncPVExistIO -// caServer::createPV() casAsyncCreatePVIO +// caServer::pvAttach() casAsyncPVAttachIO // casPV::read() casAsyncReadIO // casPV::write() casAsyncWriteIO // @@ -911,30 +963,30 @@ public: }; // -// casAsyncPVCreateIO -// - for use with caServer::createPV() +// casAsyncPVAttachIO +// - for use with caServer::pvAttach() // -class casAsyncPVCreateIO : public casAsyncIO, private casAsyncPVCIOI { +class casAsyncPVAttachIO : public casAsyncIO, private casAsyncAtIOI { public: // - // casAsyncPVCreateIO() + // casAsyncPVAttachIO() // - epicsShareFunc casAsyncPVCreateIO(const casCtx &ctx) : - casAsyncPVCIOI(ctx, *this) {} + epicsShareFunc casAsyncPVAttachIO (const casCtx &ctx) : + casAsyncAtIOI(ctx, *this) {} // // force virtual destructor // - epicsShareFunc virtual ~casAsyncPVCreateIO(); + epicsShareFunc virtual ~casAsyncPVAttachIO(); // // place notification of IO completion on the event queue // (this function does not delete the casAsyncIO object). // Only the first call to this function has any effect. // - epicsShareFunc caStatus postIOCompletion(const pvCreateReturn &retValIn) + epicsShareFunc caStatus postIOCompletion(const pvAttachReturn &retValIn) { - return this->casAsyncPVCIOI::postIOCompletion (retValIn); + return this->casAsyncAtIOI::postIOCompletion (retValIn); } // @@ -946,9 +998,20 @@ public: // epicsShareFunc caServer *getCAS() const { - return this->casAsyncPVCreateIO::getCAS(); + return this->casAsyncAtIOI::getCAS(); } }; +// +// casAsyncPVCreateIO (deprecated) +// (this class will be deleted in a future release) +// +class casAsyncPVCreateIO : public casAsyncPVAttachIO { +public: + epicsShareFunc casAsyncPVCreateIO(const casCtx &ctx) : + casAsyncPVAttachIO (ctx) {} + epicsShareFunc virtual ~casAsyncPVCreateIO(); +}; + #endif // ifdef includecasdefh (this must be the last line in this file) diff --git a/src/cas/generic/server.h b/src/cas/generic/server.h index 4fafc88c2..5844f3fa5 100644 --- a/src/cas/generic/server.h +++ b/src/cas/generic/server.h @@ -29,6 +29,9 @@ * * History * $Log$ + * Revision 1.30 1998/12/01 18:54:45 jhill + * Use EPICS_CA_BEACON_PERIOD + * * Revision 1.29 1998/10/28 23:51:01 jhill * server nolonger throws exception when a poorly formed get/put call back * request arrives. Instead a get/put call back response is sent which includes @@ -527,7 +530,7 @@ public: casDGIntfIO &outMsgIO, const caNetAddr &outAddr, const caHdr &, const pvExistReturn &); virtual caStatus createChanResponse( - const caHdr &, const pvCreateReturn &); + const caHdr &, const pvAttachReturn &); virtual caStatus readResponse( casChannelI *, const caHdr &, gdd *, const caStatus); virtual caStatus readNotifyResponse( @@ -677,7 +680,7 @@ public: // one function for each CA request type that has // asynchronous completion // - virtual caStatus createChanResponse(const caHdr &, const pvCreateReturn &); + virtual caStatus createChanResponse(const caHdr &, const pvAttachReturn &); caStatus readResponse(casChannelI *pChan, const caHdr &msg, gdd *pDesc, const caStatus status); caStatus readNotifyResponse(casChannelI *pChan, const caHdr &msg,