|
|
| (12 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. |
| May 27 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>dbdTypes.h</tt> ===
| |
| enum dbfType {
| |
| dbfUnknownT,
| |
| dbfEpicsT, // an epicsType except epicsUnknownT
| |
| dbfArrayT,
| |
| dbfStructT,
| |
| dbfMenuT,
| |
| dbfEnumT,
| |
| dbfLinkT,
| |
| dbfDeviceT
| |
| };
| |
| | |
| class DbdStruct; //describes a dbd struct definition
| |
| class DbdMenu; //describes a dbd menu definition
| |
| class DbdLink; //describes dbd link statement
| |
| class DbdDevice; //describes dbd device statement
| |
| | |
| class DbfArray : public EpicsArray {
| |
| public:
| |
| dbfType dbftype;
| |
| };
| |
| | |
| // Note that EpicsStruct:EpicsStructDef is an DbdStructDef
| |
| class DbfStruct : public EpicsStruct {
| |
| public:
| |
| };
| |
| | |
| class DbfMenu{
| |
| public:
| |
| epicsInt16 index;
| |
| DbdMenu *pmenuDef; /* address of global menu */
| |
| };
| |
| | |
| class DbfEnum{
| |
| public:
| |
| epicsInt16 index;
| |
| EpicsArray *pchoiceArray; // addr of field that is array of string
| |
| };
| |
|
| |
| enum LinkDir {
| |
| LinkDirNone,
| |
| LinkDirForward,
| |
| LinkDirIn,
| |
| LinkDirOut,
| |
| LinkDirInOut
| |
| };
| |
| | |
| class DbfLink{
| |
| public:
| |
| LinkDir dir;
| |
| DbdLink *plinkDef;
| |
| EpicsStruct dataStruct;
| |
| };
| |
| | |
| class DbfDevice{
| |
| public:
| |
| LinkDir dir;
| |
| DbdDevice *pDbdDevice;
| |
| EpicsStruct dataStruct;
| |
| };
| |
| | |
| === 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.
| |
| | |
| ==== Epics Types ====
| |
| | |
| DBD types bool,...,string all become an epicsType.
| |
| | |
| DBD type array becomes an EpicsArray if the array type maps to an epicsType
| |
| or to DbfArray if the type is not an epicsType.
| |
| | |
| DBD type struct maps to EpicsStruct if no field in the struct is epicsUnknownT;
| |
| otherwise to DbfStruct.
| |
| | |
| 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(ffloat64,float64)
| |
| ...
| |
| field(fstring,string)
| |
| field(darray,array(double[])
| |
| field(displayLimits,struct(displayLimits))
| |
| }
| |
| Then the generated header file will be
| |
| class xxxRecord : public iocRecord {
| |
| public:
| |
| epicsBoolean fbool;
| |
| epicsOctet foctet;
| |
| ...
| |
| epicsFloat64 ffloat64;
| |
| ...
| |
| EpicsString fstring;
| |
| EpicsArray darray;
| |
| EpicsStruct displayLimits;
| |
| };
| |
|
| |
| | |
| ==== DbfArray ====
| |
| | |
| This is for array fields with a type that is not a standard epicsType.
| |
| | |
| If a record definition contains:
| |
| | |
| struct(calcInpLink) {
| |
| field(link,link(in)) // NOT a standard epicsType
| |
| field(value,float64)
| |
| }
| |
| record(calc) extends iocRecord {
| |
| ...
| |
| field(inp,array(struct(calcInpLink)[]))
| |
| ...
| |
| }
| |
| | |
| Then the generated code contains:
| |
| | |
| DbfArray inp;
| |
| | |
| ==== DbfStruct ====
| |
| | |
| This is for a struct field that itself has fields that are not a standard epicsType, i.e. the epicsType is epicsUnknownT.
| |
| | |
| If a record definition contains:
| |
| | |
| struct(calcInpLink) {
| |
| field(link,link(in)) // NOT a standard epicsType
| |
| field(value,float64)
| |
| }
| |
| record(calc) extends iocRecord {
| |
| ...
| |
| field(inp,struct(calcInpLink))
| |
| ...
| |
| }
| |
| | |
| Then the generated code contains:
| |
| | |
| DbfArray inp;
| |
|
| |
| | |
| ==== DbfMenu ====
| |
| <tt>DbfMenu</tt> is described as:
| |
| class DbfMenu{
| |
| public:
| |
| epicsInt16 index;
| |
| DbdMenu *pmenuDef;
| |
| };
| |
| | |
| If a record definition contains
| |
| field(fmenu,menu(name))
| |
| Then the generated header file contains
| |
| DbfMenu fmenu;
| |
| <tt>DbfMenu</tt> provides the current menu index and also the menu definition.
| |
| | |
| ==== DbfEnum ====
| |
| <tt>DbfEnum</tt> is described as:
| |
| class DbfEnum{
| |
| public:
| |
| epicsInt16 index;
| |
| DbfArray *pchoiceArray; // addr of field that is DbfArray on choices
| |
| };
| |
| | |
| If a record definition contains
| |
| field(fenum,enum)
| |
| Then the generated header file contains
| |
| DbfEnum fenum;
| |
| <tt>pchoiceArray</tt> is the address of a field in the same record that is a
| |
| DbfArray of choices.
| |
| ==== DbfLink ====
| |
| <tt>DbfLink</tt> is described as
| |
| class DbfLink{
| |
| public:
| |
| LinkDir dir;
| |
| DbdLink *plinkDef;
| |
| EpicsStruct dataStruct;
| |
| };
| |
| If a record definition contains
| |
| field(flink,link(in))
| |
| Then the generated header file contains
| |
| DbfLink flink;
| |
| The fields of DbfLink are initialized by locating a dbd <tt>link</tt> definition that matches the <tt>dir</tt> specified in the dbd <tt>field</tt> definition.
| |
| | |
| 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.
| |
| | |
| Note that link support always implements interface <tt>DbdLinkSupport</tt>
| |
| ==== DbfDevice ====
| |
| | |
| 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>
| |
| | |
| == 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> ===
| |
| | |
| | |
| // Interface is base class for an interface
| |
| class Interface {};
| |
| class InterfaceLocator {
| |
| public:
| |
| EpicsString name;
| |
| Interface *pinterface;
| |
| };
| |
| | |
| class DbdStructFieldAttribute {
| |
| public:
| |
| EpicsString default;
| |
| epicsBoolean readonly;
| |
| epicsBoolean design;
| |
| epicsBoolean special;
| |
| epicsBoolean dynamic;
| |
| epicsInt16 asl;
| |
| };
| |
| | |
| class DbdStructField : public EpicsStructField {
| |
| public:
| |
| dbfType dbftype;
| |
| DbdStructFieldAttribute attribute;
| |
| };
| |
| | |
| class DbdStructDef : public EpicsStructDef{
| |
| public:
| |
| NODE node; // for DbdStructDefList
| |
| };
| |
| | |
| class DbdMenu{
| |
| public:
| |
| EpicsString name;
| |
| epicsInt16 nchoices;
| |
| EpicsString *pchoice[];
| |
| };
| |
| | |
| class DbdLink{ //describes dbd link statement
| |
| public:
| |
| NODE node; // For DbdLinkList.linkList
| |
| LinkDir dir;
| |
| EpicsString choiceName;
| |
| EpicsString dataStructName;
| |
| DbdLinkSupport *pinterface;
| |
| };
| |
| | |
| class DbdDevice { //describes dbd device statement
| |
| public:
| |
| NODE node; // For linkList.deviceList
| |
| LinkDir dir;
| |
| EpicsString choiceName;
| |
| EpicsString dataStructName;
| |
| EpicsString interfaceName;
| |
| Interface *pinterface;
| |
| };
| |
| | |
| class DbdUserField{ // describes a dbd userField statement
| |
| public:
| |
| NODE node; // For DbdUserFieldList
| |
| EpicsString choiceName;
| |
| epicsType type;
| |
| EpicsString dataStructName;
| |
| };
| |
| | |
| // The following describes a record type
| |
| class DbdRecordDef : extends EpicsStructDef { // describes a record type
| |
| public:
| |
| NODE node; // for DbdRecordList.recordType
| |
| LIST instanceList;
| |
| DbdRecordSupport *psupport;
| |
| };
| |
| | |
| // The following describes a record instance
| |
| class DbdUserFieldInstance {
| |
| public:
| |
| NODE node; // for DbdRecordInstance.userField
| |
| EpicsString name; // field name
| |
| DbdUserField *pDbdUserField;
| |
| DbdUserFieldHandler *pinterface;
| |
| void *pstorage; // for DbdUserField.type
| |
| EpicsStruct dataStruct;
| |
| };
| |
| | |
| // Note that EpicsStruct:EpicsStructDef is an DbdRecordDef
| |
| class DbdRecordInstance : extends EpicsStruct {
| |
| public:
| |
| NODE node; // for DbdRecord.instanceList;
| |
| EpicsString name;
| |
| LIST userField; // of DbdUserFieldInstance
| |
| };
| |
| | |
| | |
| class DbdStructDefList {
| |
| public:
| |
| LIST structType;
| |
| };
| |
| | |
| class DbdRecordDefList {
| |
| public:
| |
| LIST recordType;
| |
| };
| |
| | |
| class DbdLinkList {
| |
| public:
| |
| LIST linkList;
| |
| };
| |
| | |
| class DbdDeviceList {
| |
| public:
| |
| LIST deviceList;
| |
| };
| |
| | |
| class DbdUserFieldList {
| |
| public:
| |
| LIST userFieldList;
| |
| };
| |
| | |
| | |
| === Discussion of dbdStatements ===
| |
| ==== DbdStruct ====
| |
| The DbdStruct classes describe the fields in a dbd <tt>struct</tt> or <tt>record</tt> definition. The classes are : <tt>DbdStruct</tt>, <tt>DbdStructField</tt>,and <tt>DbdStructFieldAttribute</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>StructLifetime</tt> or <tt>DbdRecordLifetime</tt>. The implementation is automatically generated from the dbd <tt>struct</tt> or <record> statement. See below for a description of the Lifetime methods.
| |
| ; <tt>nfields</tt>
| |
| : The number of fields, e.g. fields in the structure.
| |
| ; <tt>pfields</tt>
| |
| : pointer to an array of pointers to <tt>DbdStructField</tt>.
| |
| | |
| The fields of <tt>DbdStructField</tt> are:
| |
| ; <tt>name</tt>
| |
| : The name of the field
| |
| ; <tt>basic</tt>
| |
| : The epicsType of the field. Unless this is epicsUnknownT generic code is usually provided for accessing the field.
| |
| ; <tt>type</tt>
| |
| : The dbfType for the field. Unless basic is epicsUnknownT this has the value dbfEpicsT.
| |
| ; <tt>attribute</tt>
| |
| : An DbdStructFieldAttribute for the field
| |
| | |
| <tt>DbdStructFieldAttribute</tt> has the attribute values for the field.
| |
| | |
| ==== 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 matches a DbdLink for a DbfLink instance.
| |
| ; <tt>dataStructName</tt>
| |
| : The class name of a DbfStruct for the Interface implementation
| |
| ; <tt>pinterface</tt>
| |
| : The address of the Interface implementation. The interface class is DbdLinkSupport
| |
| | |
| ==== 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 for a DbfDevice instance.
| |
| ; <tt>dataStructName</tt>
| |
| : The class name of a DbfStruct for the Interface implementation
| |
| ; <tt>interfaceName</tt>
| |
| : The name of the interface class implemented by the device support
| |
| ; <tt>pinterface</tt>
| |
| : The address of the Interface implementation.
| |
| | |
| ==== Record ====
| |
| A record type has an associated class: <tt>DbdRecord</tt>.
| |
| The fields of <tt>DbdRecord</tt> are the same as fields in <tt>DbdStruct</tt> except that they refer to a record instead of a structure.
| |
| ; <tt>node</tt>
| |
| : This is a node for <tt>DbdRecordList</tt>
| |
| ; <tt>instanceList</tt>
| |
| : The list of record instances of this record type.
| |
| ; <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 <tt>RecordLifetime</tt> methods.
| |
| ; <tt>psupport</tt>
| |
| : The address of the <tt>DbdRecordSupport</tt> for this record type.
| |
| ; <tt>nfields</tt>
| |
| : The number of fields, e.g. fields in the record.
| |
| ; <tt>pfields</tt>
| |
| : pointer to an array of pointers to <tt>DbdStructField</tt>. Each DbdStructField contains the name and type of the fields.
| |
| | |
| | |
| ==== 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
| |
| ; <tt>type</tt>
| |
| : The dbfType for the field.
| |
| ; <tt>pfield</tt>
| |
| : Address of storage for field.
| |
| ; <tt>pinterface</tt>
| |
| : The address of an implementation of interface userFieldHandler;
| |
| | |
| The fields of <tt>DbdRecordInstance</tt> are:
| |
| | |
| ; <tt>node</tt>
| |
| : A node for list <tt>DbdRecord.instanceList</tt>
| |
| ; <tt>name</tt>
| |
| : The name of the record instance
| |
| ; <tt>pDbdRecord</tt>
| |
| : The address of the description of the record type
| |
| ; <tt>precord</tt>
| |
| : The address of the storage for the record instance.
| |
| ; <tt>userField</tt>
| |
| : A DbdUserFieldInstance list for the record instance.
| |
| | |
| === DbdStructList ===
| |
| | |
| A list of all the struct definitions. The nodes are described by <tt>DbdStructNode</tt> which has fields:
| |
| | |
| ; <tt>node</tt>
| |
| : The node for the list.
| |
| ; <tt>isEpicsType<tt>
| |
| : determines if the structure is a EpicsStructDef or a DbdStruct
| |
| ; <tt>pdef</tt>
| |
| : The address of the <tt>EpicsStructDef<tt> or <tt>Db<tt> that describes the structure.
| |
| | |
| === DbdRecordList ===
| |
| | |
| The list of record types
| |
| | |
| === DbdLinkList ===
| |
| | |
| List of <tt>DbdLink</tt>
| |
| | |
| === DbdDeviceList ===
| |
| | |
| List of <tt>DbdDevice</tt>
| |
| | |
| ----
| |
| <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 DbdRecordEpicsFieldPutString {
| |
| virtual void epicsPrimitive(EpicsString *pfrom, epicsType type,
| |
| void *pstorage) = 0;
| |
| virtual void epicsString(EpicsString *pfrom,
| |
| EpicsString *pEpicsString) = 0;
| |
| virtual void epicsArray(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 an DbdRecordLifetime is automatically generated.
| |
| class DbdRecordLifetime : public EpicsStructLifetime{
| |
| public:
| |
| virtual bool initialize(DbdRecordInstance *pDbdRecordInstance) = 0;
| |
| virtual bool finalize(DbdRecordInstance *pDbdRecordInstance) = 0;
| |
| };
| |
| | |
| // every link support module implements the following interface
| |
| class DbdLinkSupport {
| |
| public:
| |
| virtual void report(EpicsString *errorMessage,
| |
| 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(epicsfString *errorMessage,
| |
| iocRecord *precord, DbffLink *pdbfLink) = 0;
| |
| virtual bool get(EpicsString *errorMessage,
| |
| iocRecord *precord, DbffLink *pdbfLink,
| |
| dbfType type, void *pfield) = 0;
| |
| virtual bool put(EpicsString *errorMessage,
| |
| iocRecord *precord, DbfLink *pdbfLink,
| |
| dbfType 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 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>DbdRecordEpicsFieldPutString</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>epicsPrimitive</tt>
| |
| : This convert a string to one of the types: <tt>epicsBoolT</tt>, ..., <epicsFloat64T</tt>
| |
| ; <tt>epicsString</tt>
| |
| : Copies a string from pfrom to pEpicsString.
| |
| ; <tt>epicsArray</tt>
| |
| : Accepts a string that has the DBD array initialization syntax, locates the string value for each element and calls either EpicsString:epicsPrimitive or EpicsString:epicsString 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 epicsPrimitive, epicsString, or epicsArray 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:epicsPrimitive or EpicsString:epicsString 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 form the dbd definition.
| |
| | |
| Lifetime has the following fields:
| |
| ; <tt>allocate</tt>
| |
| : Creates storage for the struct or record.
| |
| ; <tt>initialize</tt>
| |
| : initializes the struct or record
| |
| ; <tt>finalize</tt>
| |
| : cleans up but does not free storage
| |
| ; <tt>destroy</tt>
| |
| : frees storage
| |
| ; <tt>expose</tt>
| |
| : Given an index it returns the address of the storage. Note the the generated header files assign an index to each field.
| |
| | |
| ==== <tt>DbdLinkSupport</tt> ====
| |
| This describes the interface implemented by link support.
| |
| ==== <tt>DbdRecordSupport</tt> ====
| |
| This is the interface implemented by record support.
| |
| ==== <tt>UserFieldHandler</tt> ====
| |
| This is the interface implemented by code for user extensible fields.
| |
| | |
| ----
| |
