|
|
| (10 intermediate revisions by the same user not shown) |
| Line 1: |
Line 1: |
| = EPICS: dbdClasses - IOC record =
| | This page is obsolete. It is replaced by dbdInterfaces. |
| June 9 2005
| |
| | |
| ----
| |
| <center>
| |
| | |
| == Overview ==
| |
| | |
| </center>
| |
| | |
| This document describes the C++ class definitions for code that implements | |
| the semantics for records created from Database Definitions. The definitions
| |
| are intended for code that:
| |
| * includes header files generated from dbd definitions. Header files are generated from the following dbd definitions:
| |
| ** <tt>record</tt> - Should only be included by record support.
| |
| ** <tt>struct</tt> - Included by code that understands the struct.
| |
| ** <tt>menu</tt> - Included by code that understands the menu.
| |
| * does not include the header files.
| |
| | |
| The following headers files are described:
| |
| * <tt>dbfTypes.h</tt> - Type definitions for <tt>field</tt> definitions in <tt>struct</tt> or <tt>record></tt> DBD definitions.
| |
| * <tt>dbdStatements.h</tt> - Type definitions for DBD statements.
| |
| * <tt>dbdInterfaces.h</tt> - Type definitions for interfaces related to DBD definitions.
| |
| | |
| ----
| |
| <center>
| |
| | |
| == dbfTypes ==
| |
| </center>
| |
| File <tt>dbfTypes.h</tt> describes types and classes that are used in header
| |
| files generated from dbd <tt>struct</tt> or <tt>record</tt> field definitions.
| |
| The following naming conventions are used:
| |
| ; Dbf
| |
| : any class starting with Dbf describes a field in a generated header file. For example DbfString describes a field generated from <tt>field(name,string)</tt>.
| |
| ; Dbd
| |
| : A class name starting with Dbd describes something related to dbd definitions. For example DbdLinkSupport describes a dbd link definition.
| |
| | |
| === <tt>dbfTypes.h</tt> ===
| |
| enum dbfType {
| |
| dbfUnknownT,
| |
| dbfTypeBoolean, // epicsBoolean
| |
| dbfTypeOctet, // epicsOctet
| |
| dbfTypeInt16, // epicsInt16
| |
| dbfTypeInt32, // epicsInt32
| |
| dbfTypeInt64, // epicsInt64
| |
| dbfTypeFloat32, // epicsFloat32
| |
| dbfTypeFloat64, // epicsFloat64
| |
| dbfTypeString, // EpicsString
| |
| dbfTypeArray, // DbfArray
| |
| dbfTypeMDArray // DbfMDArray
| |
| dbfMenuT, // DbfMenu
| |
| dbfEnumT, // DbfEnum
| |
| dbfLinkT, // DbfLink
| |
| dbfDeviceT // DbfDevice
| |
| dbfTypeStruct, // DbfStruct
| |
| };
| |
| | |
| === Discussion of dbfTypes ===
| |
| | |
| The classes defined in dbfTypes together with the definitions from epicsTypes
| |
| is a complete list of the definitions that appear in header files generated
| |
| from <tt>struct</tt> and <tt>record</tt> dbd definitions.
| |
| | |
| DBD type
| |
| * bool,...,string all become an epicsType , i.e. epicsBoolean,...EpicsString
| |
| * array becomes a DbfArray or DbfMDArray.
| |
| * struct becomes a DbfStruct
| |
| * menu becomes DbfMenu
| |
| * enum becomes DbfEnum
| |
| * link becomes DbfLink
| |
| * device becomes DbfDevice
| |
| | |
| | |
| If a record is defined as:
| |
| struct(displayLimits) {
| |
| field(low,double)
| |
| field(high,double)
| |
| }
| |
| record(xxx) extends iocRecord {
| |
| ...
| |
| field(fbool,bool)
| |
| field(foctet,octet)
| |
| field(fint,int16)
| |
| ...
| |
| field(ffloat,float64)
| |
| field(fstring,string)
| |
| field(array,array(double[])
| |
| field(mdarray,array(double[,])
| |
| field(fmenu,menu(name))
| |
| field(fenum,enum)
| |
| field(flink,link(in))
| |
| field(fdevice,link(in,analogIO))
| |
| field(displayLimits,struct(displayLimits))
| |
| }
| |
| | |
| Then the generated header file will be
| |
| class xxxRecord : public iocRecord {
| |
| public:
| |
| epicsBoolean fbool;
| |
| epicsOctet foctet;
| |
| epicsInt16 fint;
| |
| ...
| |
| epicsFloat64 ffloat;
| |
| EpicsString fstring;
| |
| DbfArray array;
| |
| DbfMDArray mdarray;
| |
| DbfMenu fmenu;
| |
| DbfEnum fenum;
| |
| DbfLink flink;
| |
| DbfDevice fdevice;
| |
| DbfStruct displayLimits;
| |
| };
| |
| ----
| |
| <center>
| |
| | |
| == epicsTypes ==
| |
| </center>
| |
|
| |
| ----
| |
| <center>
| |
| | |
| == DbfMenu ==
| |
| </center>
| |
| <tt>DbfMenu</tt> is described as:
| |
| class DbfMenu{
| |
| public:
| |
| epicsInt16 index;
| |
| DbdMenu *pmenuDef;
| |
| };
| |
| | |
| <tt>DbfMenu</tt> provides the current menu index and also the menu definition.
| |
| | |
| ----
| |
| <center>
| |
| | |
| == DbfEnum ==
| |
| </center>
| |
| <tt>DbfEnum</tt> is described as:
| |
| class DbfEnum{
| |
| public:
| |
| epicsInt16 index;
| |
| DbfArray *pfield; //EpicsArray of epicsTypeString
| |
| };
| |
| | |
| <tt>pfield</tt> is the address of a field in the same record that is a
| |
| DbfArray of type EpicsString. It contains the choices.
| |
| | |
| ----
| |
| <center>
| |
| | |
| == DbfLink and DbdDevice ==
| |
| </center>
| |
|
| |
|
| |
| <tt>DbfLink</tt> is described as
| |
|
| |
| enum LinkDir {
| |
| LinkDirNone,
| |
| LinkDirForward,
| |
| LinkDirIn,
| |
| LinkDirOut,
| |
| LinkDirInOut
| |
| };
| |
|
| |
| class DbfLink{
| |
| public:
| |
| LinkDir dir;
| |
| DbdLink *plinkDef;
| |
| DbfStruct dataStruct;
| |
| };
| |
|
| |
| class DbfDevice{
| |
| public:
| |
| LinkDir dir;
| |
| DbdDevice *pDbdDevice;
| |
| DbfStruct dataStruct;
| |
| };
| |
| | |
| The fields of <tt>DbfLink</tt> are initialized as follows:
| |
| ; <tt>dir</tt>
| |
| : This is taken from either the <tt>field</tt> definition or from the <tt>DbdLink</tt> definition and is the most restrictive. For example if one says inout and the other says in then <tt>dir</tt> will be in.
| |
| ; <tt>plinkDef</tt>
| |
| : This is the address of the <tt>DbdLink</tt>.
| |
| ; <tt>dataStruct</tt>
| |
| : The describes the data structure specified in the dbd <tt>link</tt> definition. It contains data used by the link support.
| |
| | |
| Link support always implements interface <tt>DbdLinkSupport</tt>
| |
| | |
| A <tt>DbfDevice</tt> is similar to a <tt>DbfLink</tt> except that the interface implemented by the device support is also specified, i.e. instead of implementing interface <tt>DbdLinkSupport</tt>, the device support implements an interface that both record support and device support understand.
| |
| | |
| | |
| ----
| |
| <center>
| |
| | |
| == DbfStruct ==
| |
| </center>
| |
| <tt>DbfStruct</tt> is described as
| |
| | |
| class DbfStruct {
| |
| public:
| |
| DbdStruct *pdescription;
| |
| void *pstorage;
| |
| };
| |
|
| |
| | |
| ----
| |
| <center>
| |
| | |
| == dbdStatements ==
| |
| | |
| </center>
| |
| The definitions in <tt>dbdStatements.h</tt> allow introspection of ioc records. They describe everything defined in DBD definitions.
| |
| | |
| <b>NODE</b> and <b>LIST</b> specify a doubly linked list.
| |
| An implementation is not specified.
| |
| | |
| === <tt>dbdStatements.h</tt> ===
| |
| | |
| class Interface {}; // Must be an interface, i.e. pure abstract class
| |
| | |
| class DbdMenu{
| |
| public:
| |
| NODE node; // for DbdMenuList
| |
| EpicsString name;
| |
| epicsInt16 nchoices;
| |
| EpicsString *pchoice[];
| |
| };
| |
|
| |
| class DbdLink{ //describes dbd link statement
| |
| public:
| |
| NODE node; // For DbdLinkList
| |
| LinkDir dir;
| |
| EpicsString choiceName;
| |
| EpicsString dataStructName;
| |
| DbdLinkSupport *pinterface;
| |
| };
| |
|
| |
| class DbdDevice { //describes dbd device statement
| |
| public:
| |
| NODE node; // For linkList
| |
| LinkDir dir;
| |
| EpicsString choiceName;
| |
| EpicsString dataStructName;
| |
| EpicsString interfaceName;
| |
| Interface *pinterface;
| |
| };
| |
| | |
|
| |
| // Beginning of definitions for DbdStruct
| |
| class DbdFieldAttribute {
| |
| public:
| |
| EpicsString default;
| |
| epicsBoolean readonly;
| |
| epicsBoolean design;
| |
| epicsBoolean special;
| |
| epicsBoolean dynamic;
| |
| epicsInt16 asl;
| |
| };
| |
| | |
| struct DbdStringDefaults { // defaults for string
| |
| const char *bufferType;
| |
| epicsInt32 capacity;
| |
| };
| |
| | |
| struct DbdArrayDefaults { // defaults for array
| |
| dbfType type;
| |
| const char *bufferType;
| |
| epicsInt32 capacity;
| |
| epicsInt32 nelements;
| |
| };
| |
| | |
| struct DbdMDArrayDefaults { // defaults for mdarray
| |
| dbfType type;
| |
| epicsInt16 ndim
| |
| const char *bufferType;
| |
| epicsInt32 capacity;
| |
| };
| |
| | |
| struct DbdStructDefaults { // defaults for struct
| |
| DbdStructDescription *pdescription;
| |
| };
| |
| | |
| class DbdStructField {
| |
| public:
| |
| const char *name;
| |
| epicsType type;
| |
| union {
| |
| DbdStringDefaults *pstring;
| |
| DbdArrayDefaults *parray;
| |
| DbdMDArrayDefaults *pmdarray;
| |
| DbdStructDefaults *pstruct;
| |
| } defaults;
| |
| dbfType type;
| |
| DbdFieldAttribute attribute;
| |
| };
| |
| | |
| class DbdStruct{
| |
| public:
| |
| NODE node; // for DbdStructList
| |
| const char *name;
| |
| epicsInt16 nfields;
| |
| DbdStructField *pafield;//ptr to array of DbdStructField
| |
| };
| |
| | |
| | |
| class DbdRecord : public EpicsStructDef { // describes a record
| |
| public:
| |
| NODE node; // for DbdRecordList
| |
| LIST instanceList;
| |
| DbdStruct dbdStruct; // for the fields in the record
| |
| DbdRecordSupport *psupport;
| |
| };
| |
|
| |
| class DbdUserField{ // describes a dbd userField statement
| |
| public:
| |
| NODE node; // For DbdUserFieldList
| |
| EpicsString choiceName;
| |
| epicsType type;
| |
| EpicsString dataStructName;
| |
| DbdUserFieldHandler *pinterface;
| |
| };
| |
|
| |
| // The following describes a record instance
| |
| class DbdUserFieldInstance {
| |
| public:
| |
| NODE node; // for DbdRecordInstance.userField
| |
| EpicsString name; // field name
| |
| DbdUserField *pDbdUserField;
| |
| void *pstorage; // for DbdUserField.type
| |
| EpicsStruct dataStruct;
| |
| };
| |
|
| |
| class DbdRecordInstance {
| |
| public:
| |
| NODE node; // for DbdRecord.instanceList
| |
| DbfStruct dbfStruct;
| |
| void *pstorage;
| |
| EpicsString name;
| |
| LIST userField; // of DbdUserFieldInstance
| |
| };
| |
|
| |
|
| |
| class DbdStructList {
| |
| public:
| |
| LIST list;
| |
| };
| |
|
| |
| class DbdRecordList {
| |
| public:
| |
| LIST list;
| |
| };
| |
|
| |
| class DbdMenuList {
| |
| public:
| |
| LIST list;
| |
| };
| |
|
| |
| class DbdLinkList {
| |
| public:
| |
| LIST list;
| |
| };
| |
|
| |
| class DbdDeviceList {
| |
| public:
| |
| LIST list;
| |
| };
| |
|
| |
| class DbdUserFieldList {
| |
| public:
| |
| LIST list;
| |
| };
| |
| | |
| | |
| === Discussion of dbdStatements ===
| |
| ==== struct and record ====
| |
| The following classes describe the fields in a dbd <tt>struct</tt> or <tt>record</tt> definition: <tt>DbdStruct</tt>, <tt>DbdRecord</tt>, <tt>DbdField</tt>,and <tt>DbdFieldAttribute</tt>
| |
| | |
| The fields of <tt>DbdStruct</tt> are:
| |
| ; <tt>name</tt>
| |
| : The name of the struct.
| |
| ; <tt>plifetime</tt>
| |
| : The address of an implementation of interface <tt>DbdStructLifetime</tt>. The implementation is automatically generated from the dbd <tt>struct</tt>. See below for a description of the Lifetime methods.
| |
| ; <tt>nfields</tt>
| |
| : The number of fields, e.g. fields in the structure.
| |
| ; <tt>pafields</tt>
| |
| : pointer to an array of <tt>DbdField</tt>.
| |
| ; <tt>node</tt>
| |
| : A node for the list of struct definitions
| |
| | |
| The fields of <tt>DbdRecord</tt> are;
| |
| ; <tt>name</tt>
| |
| : The name of the record type.
| |
| ; <tt>plifetime</tt>
| |
| : The address of an implementation of interface <tt>DbdRecordLifetime</tt>. The implementation is automatically generated from the dbd <tt>record</tt> statement. See below for a description of the Lifetime methods.
| |
| ; <tt>nfields</tt>
| |
| : The number of fields, e.g. fields in the record.
| |
| ; <tt>pafields</tt>
| |
| : pointer to an array of <tt>DbdField</tt>.
| |
| ; <tt>node</tt>
| |
| : A node for the list of record definitions
| |
| ; <tt>node</tt>
| |
| : This is a node for <tt>DbdRecordList</tt>
| |
| ; <tt>instanceList</tt>
| |
| : The list of record instances of this record type.
| |
| ; <tt>psupport</tt>
| |
| : The address of the <tt>DbdRecordSupport</tt> for this record type.
| |
| | |
| | |
| The fields of <tt>DbdField</tt> are:
| |
| ; <tt>name</tt>
| |
| : The name of the field
| |
| ; <tt>type</tt>
| |
| : The epicsType, which is always <tt>epicsTypeUnknown</tt>
| |
| ; <tt>dbftype</tt>
| |
| : The dbfType of the field.
| |
| ; <tt>attribute</tt>
| |
| : DbdFieldAttribute for the field
| |
| | |
| The fields of <tt>DbdFieldAttribute</tt> are:
| |
| ; <tt>default</tt>
| |
| : An EpicsString providing a default value for the field.
| |
| ; <tt>readonly</tt>
| |
| : Is the field readonly?
| |
| ; <tt>design</tt>
| |
| : Is the field a design fields for DCTs?
| |
| ; <tt>special</tt>
| |
| : Should DbdRecordSupport:special be called if the field is modified.
| |
| ; <tt>dynamic</tt>
| |
| : Can the field change because of record processing?
| |
| ; <tt>asl</tt>
| |
| : The access security level.
| |
| | |
| ==== Menu ====
| |
| | |
| A dbd <tt>menu</tt> is described by class DbdMenu
| |
| | |
| The fields of DbdMenu are:
| |
| ; <tt>name</tt>
| |
| : The menu name.
| |
| ; <tt>nchoices</tt>
| |
| : The number of menu choices.
| |
| ; <tt>pchoice</tt>
| |
| : The address of an array of pointers to EpicsString. Each EpicsString is a choice.
| |
| | |
| ==== Link ====
| |
| | |
| Each dbd <tt>link</tt> definition has an associated class <tt>DbdLink</tt> with fields:
| |
| ; <tt>node</tt>
| |
| : This is a node for <tt>DbdLinkList</tt>
| |
| ; <tt>dir</tt>
| |
| : The link direction
| |
| ; <tt>choiceName</tt>
| |
| : The name that connects a DbdLink to a DbfLink instance.
| |
| ; <tt>dataStructName</tt>
| |
| : The class name of an EpicsStruct for the Interface implementation
| |
| ; <tt>pinterface</tt>
| |
| : The address of the DbdLinkSupport Interface implementation.
| |
| | |
| ==== Device ====
| |
| | |
| Each dbd <tt>device</tt> definition has an associated class <tt>DbdDevice</tt> with fields:
| |
| ; <tt>node</tt>
| |
| : This is a node for <tt>DbdDeviceList</tt>
| |
| ; <tt>dir</tt>
| |
| : The link direction
| |
| ; <tt>choiceName</tt>
| |
| : The name that matches a DbdDevice to a DbfDevice instance.
| |
| ; <tt>dataStructName</tt>
| |
| : The class name of an EpicsStruct for the Interface implementation
| |
| ; <tt>interfaceName</tt>
| |
| : The name of the interface type implemented by the device support
| |
| ; <tt>pinterface</tt>
| |
| : The address of the Interface implementation.
| |
| | |
| | |
| ==== User Defined Fields ====
| |
| | |
| Each dbd <tt>userField</tt> definition has an associated class <tt>DbdUserField</tt> with fields:
| |
| ; <tt>node</tt>
| |
| : This is a node for <tt>DbdUserFieldList</tt>
| |
| ; <tt>choiceName</tt>
| |
| : The name that matches a DbdUserField to a DbdUserFieldInstance
| |
| ; <tt>type</tt>
| |
| : The epicsType for the user field
| |
| ; <tt>dataStructName</tt>
| |
| : The class name of an EpicsStruct for the DbdUserFieldHandler
| |
| ; <tt>pinterface</tt>
| |
| : The address of the DbdUserFieldHandler implementation.
| |
| | |
| ==== Record Instance ====
| |
| | |
| A record instance has two associated classes:<tt>DbdUserFieldInstance</tt> and <tt>DbdRecordInstance</tt>.
| |
| | |
| <tt>DbdUserFieldInstance</tt> contains information for a user defined field:
| |
| ; <tt>node</tt>
| |
| : A node for list <tt>DbdRecordInstance.userField</tt>
| |
| ; <tt>name</tt>
| |
| : The name of the user defined field, i.e. the psuedo field name
| |
| ; <tt>pDbdUserField</tt>
| |
| : The DbdUserField that describes the field
| |
| ; <tt>pstorage</tt>
| |
| : Address of storage for the dbfType.
| |
| ; <tt>dataStruct</tt>
| |
| : An EpicsStruct that holds the private data for the DbdUserFieldHandler.
| |
| | |
| The fields of <tt>DbdRecordInstance</tt> are:
| |
| | |
| ; <tt>pstructDef</tt>
| |
| : address of the DbdRecord describing the record
| |
| ; <tt>pstorage</tt>
| |
| ; address of the storage for the record instance
| |
| ; <tt>node</tt>
| |
| : A node for list <tt>DbdRecord.instanceList</tt>
| |
| ; <tt>name</tt>
| |
| : The name of the record instance
| |
| ; <tt>userField</tt>
| |
| : A DbdUserFieldInstance list for the record instance.
| |
| | |
| ==== Lists ====
| |
| | |
| The following provide lists of various things:
| |
| | |
| ; <tt>DbdStructList</tt>
| |
| : The list of each struct definition
| |
| ; <tt>DbdRecordList</tt>
| |
| : The list of each record type definition
| |
| ; <tt>DbdMenuList</tt>
| |
| : The list of each menu definition
| |
| ; <tt>DbdLinkList</tt>
| |
| : The list of each link definition
| |
| ; <tt>DbdDeviceList</tt>
| |
| : The list of each device definition
| |
| ; <tt>DbdUserFieldList</tt>
| |
| : The list of each userField definition
| |
| | |
| ----
| |
| <center>
| |
| | |
| == dbdInterfaces ==
| |
| | |
| dbdInterfaces describes standard interfaces implemented by code that
| |
| supports runtime database access.
| |
| | |
| </center>
| |
| | |
| === <tt>dbdInterfaces.h</tt> ===
| |
| <tt>dbdInterfaces.h</tt> contains the following:
| |
| | |
| // The following is implemented by database access
| |
| class DbdFieldPutString {
| |
| virtual void primitive(EpicsString *pfrom, epicsType type,
| |
| void *pstorage) = 0;
| |
| virtual void string(EpicsString *pfrom,
| |
| EpicsString *pEpicsString) = 0;
| |
| virtual void array(EpicsString *pfrom,
| |
| EpicsArray *pEpicsArray) = 0;
| |
| virtual void epicsStruct(EpicsString *pfrom,
| |
| EpicsStruct *pEpicsStruct) = 0;
| |
| virtual void epicsMDArray(EpicsString *pfrom,
| |
| EpicsMDArray *pEpicsMDArray) = 0;
| |
| }
| |
| | |
| // For struct definitions that become EpicsStruct or DbfStruct fields
| |
| // An DbdStructLifetime interface is automatically generated.
| |
| class DbdStructLifetime : public EpicsStructLifetime {
| |
| public:
| |
| virtual bool initialize(DbfStruct *pDbfStruct) = 0;
| |
| virtual bool finalize(DbfStruct *pDbfStruct) = 0;
| |
| };
| |
| | |
| // For record definitions a DbdRecordLifetime is automatically generated.
| |
| class DbdRecordLifetime : public EpicsStructLifetime{
| |
| public:
| |
| virtual bool initialize(DbdRecordInstance *pDbdRecordInstance) = 0;
| |
| virtual bool finalize(DbdRecordInstance *pDbdRecordInstance) = 0;
| |
| };
| |
| | |
| // link support modules implement the following interface
| |
| class DbdLinkSupport {
| |
| public:
| |
| virtual void report(iocRecord *precord, DbfLink *pdbfLink) = 0;
| |
| virtual bool initialize(EpicsString *errorMessage,
| |
| iocRecord *precord, DbfLink *pdbfLink) = 0;
| |
| virtual bool finalize(EpicsString *errorMessage,
| |
| iocRecord *precord, DbfLink *pdbfLink) = 0;
| |
| virtual bool connect(EpicsString *errorMessage,
| |
| iocRecord *precord, DbfLink *pdbfLink) = 0;
| |
| virtual bool disconnect(EpicsString *errorMessage,
| |
| iocRecord *precord, DbffLink *pdbfLink) = 0;
| |
| virtual bool get(EpicsString *errorMessage,
| |
| iocRecord *precord, DbffLink *pdbfLink,
| |
| epicsType type, void *pfield) = 0;
| |
| virtual bool put(EpicsString *errorMessage,
| |
| iocRecord *precord, DbfLink *pdbfLink,
| |
| epicsType type, void *pfield) = 0;
| |
| };
| |
| | |
| /* record support implements the following*/
| |
| class DbdRecordSupport {
| |
| public:
| |
| virtual bool initBuffers(DbdRecordInstance *pDbdRecordInstance) = 0;
| |
| virtual bool initConnections(DbdRecordInstance *pDbdRecordInstance) = 0;
| |
| virtual bool breakConnections(DbdRecordInstance *pDbdRecordInstance) = 0;
| |
| virtual bool process(DbdRecordInstance *pDbdRecordInstance) = 0;
| |
| virtual void special(DbdRecordInstance *pDbdRecordInstance,
| |
| bool after,
| |
| epicsInt16 nlevels, // number of elements in fieldIndex
| |
| epicsInt16 fieldIndex[] // array of field indices
| |
| ) = 0;
| |
| };
| |
| | |
| class DbdUserFieldHandler {
| |
| public:
| |
| virtual bool initialize(EpicsString *errorMessage,
| |
| iocRecord *precord,DbdUserFieldInstance *puserField) = 0;
| |
| virtual bool finalize(EpicsString *errorMessage,
| |
| iocRecord *precord,DbdUserFieldInstance *puserField) = 0;
| |
| virtual bool process(EpicsString *errorMessage,
| |
| iocRecord *precord,DbdUserFieldInstance *puserField) = 0;
| |
| };
| |
| | |
| === Discussion of dbdInterfaces ===
| |
| | |
| === <tt>DbdFieldPutString</tt> ===
| |
| | |
| This is an interface, which has an implementation provided by iocCore,
| |
| that convert an <tt>EpicsString</tt> to an epicsType.
| |
| The methods are:
| |
| ; <tt>primitive</tt>
| |
| : This convert a string to one of the types: <tt>epicsBoolT</tt>, ..., <epicsTypeFloat64</tt>
| |
| ; <tt>string</tt>
| |
| : Copies a string from pfrom to pEpicsString.
| |
| ; <tt>array</tt>
| |
| : Accepts a string that has the DBD array initialization syntax, locates the string value for each element and calls either EpicsString:primitive or EpicsString:string to convert the value and put it into the correct element of <tt>EpicsArray</tt>
| |
| ; <tt>epicsStruct</tt>
| |
| : Accepts a string that has the DBD struct initialialization syntax, locates the string value associated with each field and calls primitive, string, or array to convert the value and put the result of the correct field of <tt>EpicsStruct</tt> The structure must not contain any unknown field types.
| |
| ; <tt>epicsMDArray</tt>
| |
| : Accepts a string that has the DBD array initialization syntax, locates the string value for each element and calls either EpicsString:primitive or EpicsString:string to convert the value and put it into the correct element of <tt>EpicsMDArray</tt>
| |
| === <tt>DbdStructLifetime</tt> and <tt>DbdRecordLifetime</tt> ===
| |
| Every dbd <tt>struct</tt> and <tt>record</tt> has an associated Lifetime interface implementation.
| |
| A tool is provided that automatically generates the implementation from the dbd definition.
| |
| | |
| <tt>DbdStructLifetime</tt> and <tt>DbdRecordLifetime</tt> each has the following fields:
| |
| ; <tt>allocate</tt>
| |
| : Creates storage for the struct or record.
| |
| ; <tt>destroy</tt>
| |
| : frees storage
| |
| ; <tt>exposeField</tt>
| |
| : Given an index it returns the address of the storage for the field. Note the the generated header files assign an index to each field.
| |
| ; <tt>initialize</tt>
| |
| : initializes the struct or record
| |
| ; <tt>finalize</tt>
| |
| : cleans up but does not free storage
| |
| | |
| === <tt>DbdLinkSupport</tt> ===
| |
| | |
| This is the interface implemented by the support associated with each DBD link.
| |
| | |
| <tt>DbdLinkSupport</tt> has the following methods:
| |
| ; <tt>report</tt>
| |
| : generate a report about the link instance
| |
| ; <tt>initialize</tt>
| |
| : perform initialization but do not connect
| |
| ; <tt>finalize</tt>
| |
| : undo initialization. It is assumed that disconnect has already been called.
| |
| ; <tt>connect</tt>
| |
| : connect to external source of data
| |
| ; <tt>disconnect</tt>
| |
| : disconnect from external source of data
| |
| ; <tt>get</tt>
| |
| : get a value from the external source. <tt>type</tt> specified the field type and <tt>pfield</tt> is the address of where to store the data.
| |
| ; <tt>put</tt>
| |
| : put a value from the external source. <tt>type</tt> specified the field type and <tt>pfield</tt> is the address of where to obtain the data.
| |
| === <tt>DbdRecordSupport</tt> ===
| |
| | |
| This is the interface implemented by each record support module.
| |
| <tt>DbdRecordSupport</tt> has the following methods:
| |
| | |
| ; <tt>initBuffers</tt>
| |
| : This is called during record initialization. It is responsible for creating the buffers associated with each string and array field. It may call associated support to do the initialization.
| |
| ; <tt>initConnections</tt>
| |
| : This is called to connect to external sources. It may call associated support to make the connections.
| |
| ; <tt>breakConnections</tt>
| |
| : This is called to disconnect to external sources. It may call associated support to break the connections.
| |
| ; <tt>process</tt>
| |
| : Process the record.
| |
| ; <tt>special</tt>
| |
| : This is called whenever an external source modifies a field with attribute special set to true.
| |
| | |
| | |
| === <tt>DbdUserFieldHandler</tt> ===
| |
| This is the interface implemented by code for user extensible fields.
| |
| | |
| <tt>DbdUserFieldHandler</tt> has the following fields:
| |
| ; <tt>initialize</tt>
| |
| : Initialize the user field.
| |
| ; <tt>finalize</tt>
| |
| : undo what was done during initialization
| |
| ; <tt>process</tt>
| |
| : Called near the end of record processing just before monitors are handled.
| |
| | |
| === Device Support Interfaces ===
| |
| | |
| Multiple interface definitions for device support will be defined.
| |
| Record Support and device support must agree on which interface type
| |
| is used for communication.
| |
| ----
| |
