Changes between epics 3.13 Beta 4 and 3.13 Beta 5 **** API Change **** o The canonical PV name is returned from caServer::pvExistTest() in the supplied buffer and not in a gdd data descriptor. See "casdef.h". old API: // // pvExistTest() // // The server tool is encouraged to accept multiple PV name // aliases for the same PV here. However, a unique canonical name // must be selected for each PV. // // returns S_casApp_success and fills in canonicalPVName // if the PV is in this server tool // // returns S_casApp_pvNotFound if the PV does not exist in // the server tool // // The server tool returns the unique canonical name for // the pv into the gdd. A gdd is used here because this // operation is allowed to complete asynchronously. // virtual caStatus pvExistTest (const casCtx &ctx, const char *pPVName, gdd &canonicalPVName) = 0; new API: // // pvExistTest() // // The server tool is encouraged to accept multiple PV name // aliases for the same PV here. However, one unique canonical name // must be selected by the server tool and returned to the // server lib for each PV. The server will use this canonical // name to prevent internal duplication of data structures for // process variables that have multiple aliases. // // o returns S_casApp_success and a valid canonical name string // when the PV is in this server tool // // o returns S_casApp_pvNotFound if the PV does not exist in // the server tool // // Examples: // caServerXXX::pvExistTest(const casCtx &ctx, const char *pPVName) // { // return pvExistReturn(S_casApp_success, pPVName); // common // return pvExistReturn(S_casApp_pvNotFound); // no PV by that name // // char pName[9] = "myPVName"; // return pvExistReturn(S_casApp_success, pName); // also common // return pvExistReturn(S_casApp_asyncCompletion); // not now // } // virtual pvExistReturn pvExistTest (const casCtx &ctx, const char *pPVName)=0; **** API Change **** o The server tool must now use one of class casAsyncReadIO, casAsyncWriteIO, or casAsyncPVExistIO in place of casAsyncIO. See "casdef.h". **** API Change **** o Virtual function prototype change: Before: "aitEnum casPV::bestExternalType()" After: "aitEnum casPV::bestExternalType() const" **** API Change **** o The following virtual functions were added to casPV: // // Returns the maximum bounding box for all present and // future data stored within the PV. // // The routine "dimension()" returns the maximum // number of dimensions in the hypercube (0=scaler, // 1=array, 2=plane, 3=cube ...}. // // The routine "maxBound(dimension)" returns the // maximum length of a particular dimension of the // hypercube as follows: // // dim equal to 0 1 3 ... // ------------------------------------------- // hypercube // type // --------- // // array array // length // // plane x y // // cube x y z // // . // . // . // // The default (base) "dimension()" returns zero (scaler). // The default (base) "maxBound()" returns scaler bounds // for all dimensions. // // Clients will see that the PV's data is scaler if // these routines are not supplied in the derived class. // // If the "dimension" argument to maxBounds() is set to // zero then the bound on the first dimension is being // fetched. If the "dimension" argument to maxBound() is // set to one then the bound on the second dimension // are being fetched... // virtual unsigned maxDimension() const; // return zero if scaler virtual aitIndex maxBound (unsigned dimension) const; The defaults in base class casPV implement identical behavior to the past if these routines are not supplied by the derived class. Changes between epics 3.13 Beta 6 and 3.13 Beta ???? **** API Change **** o The member function "casChannel::postEvent()" has been replaced by "casChannel::postAccessRightsEvent()". An access rights state change event is now posted to the client each time that "casChannel::postAccessRightsEvent()" is called. o The virtual functions "casChannel::interestRegister()" and "casChannel::interestDelete()" have been eliminated. o The constructor "caServer::caServer()" no-longer has an argument specifying the maximum PV name length. It also no longer has an argument specifying the maximum simultaneous IO operations. THIS IS LIKELY TO BREAK YOUR CODE BECAUSE THE FIRST TWO ARGUMENTS WERE REMOVED AND THERE ARE DEFAULT ARGUMENTS. This change was made because we would like to remove all limits on the PV name length (real or perceived). We also felt that if a server tool wishes to postpone an asynchronious IO operation then it should return S_casApp_postponeAsyncIO from caServer::pvExistTest() and caServer::createPV() (instead of relying on the server to keep track of the number of simultaneous asynchronous IO operations). This provides a less complex and more flexible API. o The member function "casPV::casPV(caServer &cas)" replaces the member function "casPV::casPV(const casCtx &ctx, const char * const pPVName)". o The virtual member function "caServer::createPV(const casCtx &ctx, const char *pPVName)" has been replaced by the virtual member function "pvCreateReturn createPV (const casCtx &ctx, const char *pPVAliasName)" This change was made in order to allow asynchronous completion of a PV create operation. o The data type (class) pvExistReturn has been changed to an enum - "enum pvExistReturn {pverExistsHere, pverDoesNotExistHere, pverAsyncCompletion, pverNoMemoryForAsyncOP}" This impacts the virtual member function "pvExistTest (const casCtx &ctx, const char *pPVAliasName)" o The server tool is now required to supply the virtual function "casPV::getName()" so that the server is able to identify the process variable when diagnostics are printed. o The virtual function casPV::maxSimultAsyncOps() has been eliminated in favor of allowing the server tool to return S_casApp_postponeAsyncIO from casPV::read() or casPV::write() when there are too many simultaneous asynchronous IO operations and the server tool would like to postpone the current (and future) request(s) until one of the outstanding asynchronous IO operations (read or write) completes. o All "show()" virtual member functions in the interface classes have had the "const" attribute added. **** Semantic Change **** o IMPORTANT: It is now the responsibility of the server tool to detect attempts by the server lib to create a 2nd PV with the same canonical name as an existing PV and avoid this by returning a pointer to the first PV created. Likewise, if there are several aliases for one canonical PV name then it is the responsibility of the server tool to return "pvExistsHere" from "caServerDerived::pvExistTest()" for each of the aliases. Likewise, if there are several aliases for one canonical PV name then it is the responsibility of the server tool to return a single PV with the canonical name from "caServerDerived::createPV()" (even if createPV() is called multiple times each with a different alias name). This change was made to simplify the API and to eliminate redundant data structures and labor occurring within the server tool and the server library. o PV creation is now allowed to complete asynchronously o It is now the responsibility of the server tool to limit the number of simultaneous asynchronous IO operations allowed (by returning S_casApp_postponeAsyncIO). Changes between epics 3.13 Beta 11 and 3.13 Beta 12 **** API Change **** 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. o The hash table template class resTable now requires a PV count estimate argument to its the constructor, and its init(PV count estimate) member function has been eliminated (server tools frequently implement a string hash table based on class resTable). o The delay argument passed to fileDescriptorManager.process(delay) has been changed from type osiTime to the C++ primitive type double. o The arithmetic operators in class osiTime now return type double, and not type osiTime. o In class osiTimer the use of type osiBool was eliminated in favor of the now universally implemented ANSI STD C++ "bool" type. o In class osiTimer type double, and not type osiTime, is returned from virtual member function delay(). o The public const event mask member data in the caServer class were changed to member functions in order to avoid problems on some compiler where const event masks cant be created until the server is fully constructed. The constants have been replaced by the following member functions. casEventMask valueEventMask() const; // DBE_VALUE registerEvent("value") casEventMask logEventMask() const; // DBE_LOG registerEvent("log") casEventMask alarmEventMask() const; // DBE_ALARM registerEvent("alarm")