V4 Design: dbdClass

EPICS: dbdClasses - IOC record

June 21 2005

---

Overview

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:
  • record - Should only be included by record support.
  • struct - Included by code that understands the struct.
  • menu - Included by code that understands the menu.
• does not include the header files.

The following headers files are described:

• dbfTypes.h - Type definitions for field definitions in struct or record> DBD definitions.
• dbdStatements.h - Type definitions for DBD statements.
• dbdInterfaces.h - Type definitions for interfaces related to DBD definitions.

---

dbfTypes

File dbfTypes.h describes types and classes that are used in header files generated from dbd struct or record field definitions. The following naming conventions are used:

C++ struct vs class

A C++ class is used for a class that has methods and struct is used for a class that has only data.

Dbf

any class starting with Dbf describes a field in a generated header file. For example DbfString describes a field generated from field(name,string).

Dbd

A class name starting with Dbd describes something related to dbd definitions. For example DbdLinkSupport describes a dbd link definition.

dbfTypes.h

Every field in the header files generated from DBD struct and record definitions has one on the following types:

    enum dbfType {
        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

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;
   };

---

Database Field Types

epicsTypes

Fields of type epicsBoolean, epicsOctet, epicsInt16, epicsInt32, epicsInt64, epicsFloat32, or epicsFloat64 are all a C++ fundamental type. When a record instance is created these are all initialized to 0.

Record support code can directly access such fields via the generated header file. Some examples are:

    xxxRecord &record;
    epicsInt16 myint;
    ...
    record.ffloat = 10.0
    ...
    myint = record.fint;

Code that does not include the generated header file can access these fields via the introspecion interfaces described later in this document. For example code that expects a epicsFloat64 field can access it via

    EpicsString pvname;
    DbAddr *pDbAddr;
    epicsFloat64 *pfield;
    ...
    
    pDbAddr = pDbdLocate->nameToAddr(pvname);
    if(!pDbAddr || (pDbAddr->getType != dbfTypeFloat64)) // do SOMETHING
    pfield = (epicsFloat64 *)pDbAddr->getAddr();
    *pfield = 10.0;
    

A field of type EpicsString is initialized via the default constructor for EpicsString, which means that no EpicsBuffer is created. Record support must call createBuffer.

Code that includes the generated header file can call the EpicsString methods. For an example lets assume that record support creates a contiguous buffer and the record support wants to print the string value.

    xxxRecord &record;
    const epicsOctet *pdata;
    epicsInt32 len;
    ...
    if(!record.string->expose(0,len,pdata)) {// do something}
    ...
    printf("%.*s\n",pdata,len);

Code that does not include the header file can use the introspection methods to locate the field. For example:

    EpicsString pvname;
    DbAddr *pDbAddr;
    EpicsString *pfield;
    ...
    
    pDbAddr = pDbdLocate->nameToAddr(pvname);
    if(!pDbAddr || (pDbAddr->getType != dbfTypeString)) // do SOMETHING
    pfield = (EpicsString *)pDbAddr->getAddr();
    ...
    

DbfArray

DbfArray is:

    struct DbfArray {
        dbfType type;
        EpicsArray *parray;
    };
       

Code that includes the header file can directly access the DbfArray. Code that does not include the header file can use the introspection methods to get the address of the DbfArray.

Class definitions for arrays of types octet, int16, int32, int64, float32, and float64 are described below. These classes make it easy to access a DbfArray of each of these types.

An example of how the classes can be used is:

    DbfArray  array;
    ...
    Float64Array floatArray(array);
    epicsFloat64 *pdata = new epicsFloat64[10];
    ...
    floatArray.put(0,10,pdata);

DbfMDArray

DbfMDArray is:

Need something like for DbfArray except that convenience classes will be

    class BasicTypeMDArray;
    class OctetMDArray ;
    class Int32MDArray ;
    class Int64MDArray ;
    class Float32MDArray ;
    class Float64MDArray ;
    

DbfMenu

DbfMenu is described as:

    struct DbfMenu{
        epicsInt16    index;
        DbdMenu  *pmenuDef;
    };

DbfMenu provides the current menu index and also the menu definition. A field of type DbfMenu is automatically initialized by dbLoadRecords.

A DbfMenu field can be accessed via the generated header file of via the introspection methods.

Given the address of a menu field the following show how to access the menu data.

    DbfMenu *pmenu;
    epicsInt16 index;
    EpicsString *name;

    index = pmenu->index;

    index = pmenu->index;
    name = pmenu->pmenuDef->papchoice[index];

Question?

1. What are the rules for changing menu choices?
2. Should a class be defined for accessing DbdMenu?

DbfEnum

DbfEnum is described as:

    struct DbfEnum{
        epicsInt16  index;
        DbfArray  *pfield; //EpicsArray of epicsTypeString
    };

pfield is the address of a field in the same record that is a DbfArray of type EpicsString. It contains the choices.

A field of type DbfEnum is automatically initialized by dbLoadRecords.

Questions?

1. Do we want convenience classes for accessing choices?

DbfLink and DbdDevice

DbfLink is described as

    enum LinkDir {
        LinkDirNone,
        LinkDirForward,
        LinkDirIn,
        LinkDirOut,
        LinkDirInOut
    };
   
    struct DbfLink{ 
        LinkDir   dir;
        DbdLink   *plinkDef;
        DbfStruct dataStruct;
    };
   
    struct DbfDevice{
        LinkDir   dir;
        DbdDevice *pDbdDevice;
        DbfStruct dataStruct;
    };

The fields of DbfLink are initialized by dbLoadRecords as follows:

dir

This is taken from either the field definition or from the DbdLink definition and is the most restrictive. For example if one says inout and the other says in then dir will be in.

plinkDef

This is the address of the DbdLink.

dataStruct

The describes the data structure specified in the dbd link definition. It contains data used by the link support.

Link support always implements interface DbdLinkSupport

A DbfDevice is similar to a DbfLink except that the interface implemented by the device support is also specified, i.e. instead of implementing interface DbdLinkSupport, the device support implements an interface that both record support and device support understand.

DbfStruct

DbfStruct is described as

    struct DbfStruct {
        DbdStruct *pdescription;
        void      *pstorage;
    };

The fields of DbfStruct are initialized by dbLoadRecords as follows:

pdescription

This is initialized via the structure name specified in field definition.

pstorage

This is initialized by calling DbdStructLifetime:allocate

---

dbdStatements

The definitions in dbdStatements.h describe everything defined in DBD definitions.

In the definitions:

• NODE and LIST specify a doubly linked list. An implementation is not specified.
• class Interface {}; Represents an unspecified interface.

DbdMenu

    struct DbdMenu{
        NODE        node; // for DbdBase:menuList
        EpicsString name;
        epicsInt16  nchoices;
        EpicsString **papchoice; // ptr to array of ptr to EpicsString
    };

The fields of DbdMenu are:

node

node for DbdBase:menuList

name

The menu name.

nchoices

The number of menu choices.

pchoice

The address of an array of pointers to EpicsString. Each EpicsString is a choice.

DbdLink and DbdDevice

    struct DbdLink{ //describes dbd link statement
        NODE            node; // For DbdBase:linkList
        LinkDir         dir;
        EpicsString     choiceName;
        EpicsString     dataStructName;
        DbdLinkSupport  *pinterface;
        }; 

    struct DbdDevice { //describes dbd device statement
        NODE        node; // For DbdBase:deviceList
        LinkDir     dir;
        EpicsString choiceName;
        EpicsString dataStructName;
        EpicsString interfaceName;
        Interface   *pinterface;
    };

A dbd link definition is described by DbdLink

node

This is a node for DbdLinkList

dir

The link direction

choiceName

The name that connects a DbdLink to a DbfLink instance.

dataStructName

The class name of an DbdStruct for the Interface implementation

pinterface

The address of the DbdLinkSupport Interface implementation.

Each dbd device definition is described by DbdDevice

node

This is a node for DbdDeviceList

dir

The link direction

choiceName

The name that matches a DbdDevice to a DbfDevice instance.

dataStructName

The class name of an EpicsStruct for the Interface implementation

interfaceName

The name of the interface type implemented by the device support

pinterface

The address of the Interface implementation.

DbdStruct and DbdRecord

    struct DbdAttribute {
        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
        DbdStruct *pdescription;
    };

    struct DbdField {
        const char *name;
        dbfType   type;
        union {
            DbdStringDefaults  *pstring;
            DbdArrayDefaults   *parray;
            DbdMDArrayDefaults *pmdarray;
            DbdStructDefaults  *pstruct;
        } defaults;
        DbdAttribute attribute;
    };

    struct DbdStruct{ // describes a struct
        NODE             node; // for DbdBase:structList
        const char       *name;
        epicsInt16       nfields;
        DbdField         **papfield;//ptr to array of ptr to DbdField
        DbdStructLifetime *plifetime;
    };

    struct DbdRecord { // describes a record
        NODE              node; // for DbdBase:recordList
        LIST              instanceList;
        const char        *name;
        epicsInt16        nfields;
        DbdField          **papfield;//ptr to array of ptr to DbdField
        DbdRecordSupport  *psupport;
        DbdRecordLifetime *plifetime;
    };

The following describe the fields in a dbd struct or record definition: DbdStruct, DbdRecord, DbdField,and DbdAttribute

The fields of DbdStruct are:

node

node for DbdBase:structList

name

The name of the struct.

nfields

The number of fields, e.g. fields in the structure.

pafields

pointer to an array of DbdField.

plifetime

The address of an implementation of interface DbdStructLifetime. The implementation is automatically generated from the dbd struct. See below for a description of the Lifetime methods.

The fields of DbdRecord are;

node

node for DbdBase:recordList

instanceList

list of instances of this record type

name

The name of the record type.

nfields

The number of fields, e.g. fields in the record.

pafields

pointer to an array of DbdField.

psupport

The address of the DbdRecordSupport for this record type.

plifetime

The address of an implementation of interface DbdRecordLifetime. The implementation is automatically generated from the dbd record statement. See below for a description of the Lifetime methods.

The fields of DbdField are:

name

The name of the field

type

The dbfType of the field.

defaults

a union of default values. The default values depend on the record type definitions. Most types do not have associated default values. Note that these are defaults for the description of the field NOT for values to put in the field.

attribute

DbdAttribute for the field

The fields of DbdAttribute are:

default

An EpicsString providing a default value for the field.

readonly

Is the field readonly?

design

Is the field a design fields for DCTs?

special

Should DbdRecordSupport:special be called if the field is modified.

dynamic

Can the field change because of record processing?

asl

The access security level.

Record Instance

    struct DbdUserField{ // describes a dbd userField statement
        NODE                node; // For DbdBase:userFieldList
        EpicsString         choiceName;
        epicsType           type;
        EpicsString         dataStructName;
        DbdUserFieldHandler *pinterface;
    };
   
    struct DbdUserFieldInstance {
        NODE         node; // for DbdRecordInstance.userField
        EpicsString  name; // user field name
        dbfType      sourceType;
        void         *psource;
        DbdUserField *pDbdUserField;
        void         *pstorage; // for DbdUserField.type
        DbfStruct    dataStruct;
    };
   
    struct DbdRecordInstance {
        NODE         node; // for DbdRecord.instanceList
        DbdRecord    *pDbdRecord;
        void         *pstorage;
        EpicsString  name;
        LIST         userField; // of DbdUserFieldInstance
    };

NOTE: userField has NOT been defined.

Each dbd userField definition has an associated class DbdUserField with fields:

node

This is a node for DbdUserFieldList

choiceName

The name that matches a DbdUserField to a DbdUserFieldInstance

type

The epicsType for the user field

dataStructName

The class name of an EpicsStruct for the DbdUserFieldHandler

pinterface

The address of the DbdUserFieldHandler implementation.

A record instance has two associated classes:DbdUserFieldInstance and DbdRecordInstance.

DbdUserFieldInstance contains information for a user defined field:

node

A node for list DbdRecordInstance.userField

name

The name of the user defined field, i.e. the psuedo field name

sourceType

the type of the field of the record that DbdUserFieldHandler accesses.

psource

The address of the field that DbdUserFieldHandler accesses.

pDbdUserField

The DbdUserField that describes the field

pstorage

Address of storage for the dbfType.

dataStruct

An DbfStruct that holds the private data for the DbdUserFieldHandler.

The fields of DbdRecordInstance are:

node

A node for list DbdRecord.instanceList

pDbdRecord

address of the DbdRecord describing the record

pstorage

address of the storage for the record instance

name

The name of the record instance

userField

DbdUserFieldInstance list for the record instance.

Base

   struct DbdBase {
        LIST structList;
        LIST recordList;
        LIST menuList;
        LIST linkList;
        LIST deviceList;
        LIST userFieldList;
   };

This is only accessable via the introspection interfaces described in the next section. They are shown here for completeness.

The following provide lists of various things:

structList

The list of each struct definition

recordList

The list of each record type definition

menuList

The list of each menu definition

linkList

The list of each link definition

deviceList

The list of each device definition

userFieldList

The list of each DbdUserField definition

---

Introspection

This section describes interfaces provided by iocCore for locating information related to Dbf and Dbd definitions.

    class DbAddr {
    public:
        DbAddr(EpicsString &pvname);
        DbAddr(EpicsString &recordName, EpicsString &fieldName);
        virtual ~DbAddr();
        virtual epicsType getType() = 0;
        virtual void      *getAddr() = 0;
        virtual DbdRecordInstance *getDbdRecordInstance() = 0;
        virtual void getIndex(epicsInt16 *nlevels,epicsInt16 *paindex) = 0; 
    };

    class DbdLocate {
    public:
        DbdMenu *menu(EpicsString &menuName);
        DbdLink *link(EpicsString &choiceName);
        DbdDevice *device(EpicsString &choiceName);
        DbdStruct *struct(EpicsString &name);
        DbdRecord *record(EpicsString &name);
        DbdUserField *userField(EpicsString &name);
        DbdRecordInstance *recordInstance(EpicsString &name);
        DbAddr *nameToAddr(EpicsString &pvname);
        void registerRecordSupport(EpicsString &name,
                 DbdRecordSupport &support);
        void registerLinkSupport(EpicsString &choiceName,
                 EpicsString &dataStructName, DbdLinkSupport &support);
        void registerDeviceSupport(EpicsString &choiceName,
                 EpicsString &dataStructName, EpicsString &interfaceName,
                 DbdLinkSupport &support);
    };
    extern DbdLocate *pDbdLocate;

    class DbdRecordIntrospect {
    public:
        epicsInt16 fieldIndex(DbdRecordInstance &instance,EpicsString &name);
        void *fieldAddr(DbdRecordInstance &instance, epicsInt16 index);
    };

---

Field access

This section describes interfaces provided by iocCore for modifying fields in database reords.

DbfArray access

Classes are provided for accessing DbfArray fields that are arrays of any of the following primitive types: octet, int, float.

    class BasicTypeArray {
    public:
        BasicTypeArray(DbfArray &array);
        BasicTypeArray(DbfArray &array,
                   const char *bufferType, epicsInt32 capacity);
        BasicTypeArray(DbfArray &array,
                   BufferCreator *creator, epicsInt32 capacity);
        virtual ~BasicTypeArray();
        epicsInt32 getElementSize() const;
        void useBuffer(const char *bufferType, epicsInt32 capacity = 0);
        void useBuffer(EpicsBufferCreator *creator, epicsInt32 capacity = 0);
        void destroy();
        EpicsBufferCreator *creator() const;
        bool mutable() const;
    protected:
        DbfArray &array;
    private:
        BasicTypeArray(const EpicsBasicTypeArray &);// No copy constructor
        // No assignment operator
        BasicTypeArray& operator=(const EpicsBasicTypeArray &);
    };

    class Int16Array : public BasicTypeArray{
    public:
        Int16Array(DbfArray &array);
        Int16Array(DbfArray &array,
                   const char *bufferType, epicsInt32 capacity);
        Int16Array(DbfArray &array,
                   EpicsBufferCreator *creator, epicsInt32 capacity);
        ~Int16Array();
        epicsInt16 *element(epicsInt32 index);
        const epicsInt16 * element(epicsInt32 index) const;
        epicsInt32 get(epicsInt32 offset, epicsInt32 len,
                       epicsInt16 *pto) const;
        epicsInt32 put(epicsInt32 offset, epicsInt32 len,
                       const epicsInt16 *pfrom);

        // These are similar to Buffer, measured in elements not octets
        void reserve(epicsInt32 capacity);
        epicsInt32 capacity() const;
        void resize(epicsInt32 newsize);
        epicsInt32 size() const;
        epicsInt32 maxSize() const;
        void expose(epicsInt32 offset, epicsInt32 &len,
                    epicsInt16 *&pdata);
        void expose(epicsInt32 offset, epicsInt32 &len,
                    const epicsInt16 *&pdata) const;
    private:
        Int16Array(const EpicsInt16Array &);            // No copy constructor
        Int16Array& operator=(const EpicsInt16Array &); // No assignment operator
    };

    // The following are like Int16Array except for type
    class OctetArray ;
    class Int32Array ;
    class Int16Array;
    class Int64Array ;
    class Float32Array ;
    class Float64Array ;

DbdFieldPutString

Given an EpicsString, these methods put a value in a Dbf field

class DbdFieldPutString {
public:
    void primitive(EpicsString *pfrom, dbfType type, void *pstorage);
    void string(EpicsString *pfrom, EpicsString *pEpicsString);
    void array(EpicsString *pfrom, DbfArray *parray);
    void dbfStruct(EpicsString *pfrom, DbfStruct *pstruct);
    void dbfMDArray(EpicsString *pfrom, DbfMDArray *parray);
}
extern DbdFieldPutString *pDbdFieldPutString;

DbdFieldPutString is an interface, which has an implementation provided by iocCore, that convert an EpicsString to an dbfType.

The methods are:

primitive

This convert a string to one of the types: epicsBoolean, ..., epicsFloat64

string

Copies an EpicsString to an EpicsString

array

Accepts a string that has the DBD array initialization syntax, locates the string value for each element and calls either DbdFieldPutString:primitive or DbdFieldPutString:string to convert the value and put it into the correct element of DbfArray

dbfStruct

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 DbfStruct

dbfMDArray

Accepts a string that has the DBD array initialization syntax, locates the string value for each element and calls either DbdFieldPutString:primitive or DbdFieldPutString:string to convert the value and put it into the correct element of DbfMDArray

---

Automatically Generated Interfaces

// For struct definitions
// An DbdStructLifetime interface is automatically generated.
class DbdStructLifetime {
public:
    virtual void allocate(DbfStruct &struct) = 0;
    virtual void destroy(DbfStruct &struct) = 0;
    virtual bool initialize(DbfStruct *pDbfStruct) = 0;
    virtual bool finalize(DbfStruct *pDbfStruct) = 0;
    virtual void *exposeField(DbfStruct &struct, epicsInt16 index) = 0;
};

// For record definitions a DbdRecordLifetime is automatically generated.
class DbdRecordLifetime{
public:
    virtual void allocate(DbdRecordInstance *pDbdRecordInstance) = 0;
    virtual void destroy(DbdRecordInstance *pDbdRecordInstance) = 0;
    virtual bool initialize(DbdRecordInstance *pDbdRecordInstance) = 0;
    virtual bool finalize(DbdRecordInstance *pDbdRecordInstance) = 0;
    virtual void *exposeField(DbdRecordInstance *pDbdRecordInstance,
                            epicsInt16 index) = 0;
};

Every dbd struct and record has an associated Lifetime interface implementation. A tool is provided that automatically generates the implementation from the dbd definition.

DbdStructLifetime and DbdRecordLifetime each has the following fields:

allocate

Creates storage for the struct or record.

destroy

frees storage

exposeField

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.

initialize

initializes the struct or record

finalize

cleans up but does not free storage

---

Record Support

/* 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;
};

This is the interface implemented by each record support module. DbdRecordSupport has the following methods:

initBuffers

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.

initConnections

This is called to connect to external sources. It may call associated support to make the connections.

breakConnections

This is called to disconnect to external sources. It may call associated support to break the connections.

process

Process the record.

special

This is called whenever an external source modifies a field with attribute special set to true.

---

User Field Support

class DbdUserFieldHandler {
public:
    virtual bool initialize(
                     iocRecord *precord,DbdUserFieldInstance *puserField) = 0;
    virtual bool finalize(
                     iocRecord *precord,DbdUserFieldInstance *puserField) = 0;
    virtual bool process(
                     iocRecord *precord,DbdUserFieldInstance *puserField) = 0;
};

This is the interface implemented by code for user extensible fields.

DbdUserFieldHandler has the following fields:

initialize

Initialize the user field.

finalize

undo what was done during initialization

process

Called near the end of record processing just before monitors are handled.

---

Link and Device Support

// link support modules implement the following interface
class DbdLinkSupport {
public:
    virtual void report(iocRecord *precord, DbfLink *pdbfLink) = 0;
    virtual bool initialize(iocRecord *precord, DbfLink *pdbfLink) = 0;
    virtual bool finalize(iocRecord *precord, DbfLink *pdbfLink) = 0;
    virtual bool connect(iocRecord *precord, DbfLink *pdbfLink) = 0;
    virtual bool disconnect(iocRecord *precord, DbffLink *pdbfLink) = 0;
    virtual bool get(iocRecord *precord, DbffLink *pdbfLink,
                    epicsType type, void *pfield) = 0;
    virtual bool put(iocRecord *precord, DbfLink *pdbfLink,
                     epicsType type, void *pfield) = 0;
};

This is the interface implemented by the support associated with each DBD link.

DbdLinkSupport has the following methods:

report

generate a report about the link instance

initialize

perform initialization but do not connect

finalize

undo initialization. It is assumed that disconnect has already been called.

connect

connect to external source of data

disconnect

disconnect from external source of data

get

get a value from the external source. type specified the field type and pfield is the address of where to store the data.

put

put a value from the external source. type specified the field type and pfield is the address of where to obtain the data.

Multiple interface definitions for device support will be defined. Record Support and device support must agree on which interface type is used for communication.

---

Runtime Database Access

Record Support

Must allow for

• post any field that is modified either by record support or by associated device support.

Link Support

Must allow for

• get
• getNotify
• put
• putNotify
• post any field that is modified

External Access

Must allow for

• permission to get or put
• get
• get after process
• put
• put and process
• put process and notify
• post any field that is modified