V4 Design: dbdClass

From EPICSWIKI
Revision as of 19:20, 1 June 2005 by MartyKraimer (talk | contribs)

EPICS: dbdClasses - IOC record

June 1 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:

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

enum dbfType {
    dbfUnknownT,
    dbfEpicsT,  // an epicsType except epicsUnknownT
    dbfArrayT,
    dbfStructT,
    dbfMenuT,
    dbfEnumT,
    dbfLinkT,
    dbfDeviceT
    dbfMDArrayT
};

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

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

class DbfMDArray : public EpicsMDArray {
public:
};

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 struct and record dbd definitions.

Epics Types

DBD types bool,...,string all become an epicsType.

DBD type array becomes an EpicsArray if the array type is not epicsUnknownT. Otherwise it maps to DbfArray.

DBD type struct maps to EpicsStruct if no field in the struct is epicsUnknownT. Otherwise ir maps 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 epicsUnknownT. DbfArray provides the dbfType.

If a record definition contains: 

    struct(calcInpLink) {
        field(link,link(in))       // epicsType is epicsUnknownT
        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 with at least one field of type epicsUnknownT.

If a record definition contains: 

    struct(calcInpLink) {
        field(link,link(in))     // epicsType is epicsUnknownT
        field(value,float64)
    }
    record(calc) extends iocRecord {
        ...
        field(inp,struct(calcInpLink))
        ...
    }

Then the generated code contains: 

    DbfStruct inp;

DbfMenu

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

DbfMenu provides the current menu index and also the menu definition.

DbfEnum

DbfEnum is described as: 

    class DbfEnum{
    public:
        epicsInt16  index;
        EpicsArray  *pchoiceArray; //EpicsArray of epicsStringT
    };

If a record definition contains 

    field(fenum,enum)

Then the generated header file contains 

    DbfEnum fenum;

pchoiceArray is the address of a field in the same record that is an EpicsArray of type epicsStringT. It contains the choices.

DbfLink

DbfLink 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 link definition that matches the dir specified in the dbd field definition.

The fields of DbfLink are initialized 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.

Note that link support always implements interface DbdLinkSupport

DbfDevice

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.


dbdStatements

The definitions in dbdStatements.h allow introspection of ioc records. They describe everything defined in DBD definitions.

NODE and LIST specify a doubly linked list. An implementation is not specified.

dbdStatements.h

class Interface {}; // Must be an interface, i.e. pure abstract class

class DbdFieldAttribute {
public:
    EpicsString  default;
    epicsBoolean readonly;
    epicsBoolean design;
    epicsBoolean special;
    epicsBoolean dynamic;
    epicsInt16   asl;
};

class DbdField : public EpicsStructField {
public:
    dbfType           dbftype;
    DbdFieldAttribute attribute;
};

class DbdStruct : public EpicsStructDef{ // describes a struct
public:
    NODE              node; // for DbdStructList
};

class DbdRecord : public EpicsStructDef { // describes a record
public:
    NODE              node; // for DbdRecordList
    LIST              instanceList;
    DbdRecordSupport  *psupport;
};

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

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 : extends EpicsStruct {
public:
    NODE         node; // for DbdRecord.instanceList
    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 struct or record definition: DbdStruct, DbdRecord, DbdField,and DbdFieldAttribute

The fields of DbdStruct are:

name
The name of the struct.
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.
nfields
The number of fields, e.g. fields in the structure.
pfields
pointer to an array of pointers to DbdField.
node
A node for the list of struct definitions

The fields of DbdRecord are;

name
The name of the 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.
nfields
The number of fields, e.g. fields in the record.
pfields
pointer to an array of pointers to DbdField.
node
A node for the list of record definitions
node
This is a node for DbdRecordList
instanceList
The list of record instances of this record type.
psupport
The address of the DbdRecordSupport for this record type.


The fields of DbdField are:

name
The name of the field
type
The epicsType, which is always epicsUnknownT
dbftype
The dbfType of the field.
attribute
DbdFieldAttribute for the field

The fields of DbdFieldAttribute 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.

Menu

A dbd menu is described by class DbdMenu

The fields of DbdMenu are:

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.

Link

Each dbd link definition has an associated class DbdLink with fields:

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 EpicsStruct for the Interface implementation
pinterface
The address of the DbdLinkSupport Interface implementation.

Device

Each dbd device definition has an associated class DbdDevice with fields:

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.


User Defined Fields

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.

Record Instance

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
pDbdUserField
The DbdUserField that describes the field
pstorage
Address of storage for the dbfType.
dataStruct
An EpicsStruct that holds the private data for the DbdUserFieldHandler.

The fields of DbdRecordInstance are:

pstructDef
address of the DbdRecord describing the record
pstorage
address of the storage for the record instance
node
A node for list DbdRecord.instanceList
name
The name of the record instance
userField
A DbdUserFieldInstance list for the record instance.

Lists

The following provide lists of various things:

DbdStructList
The list of each struct definition
DbdRecordList
The list of each record type definition
DbdMenuList
The list of each menu definition
DbdLinkList
The list of each link definition
DbdDeviceList
The list of each device definition
DbdUserFieldList
The list of each userField definition

dbdInterfaces

dbdInterfaces describes standard interfaces implemented by code that supports runtime database access.

dbdInterfaces.h

dbdInterfaces.h 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

DbdFieldPutString

This is an interface, which has an implementation provided by iocCore, that convert an EpicsString to an epicsType. The methods are:

primitive
This convert a string to one of the types: epicsBoolT, ..., <epicsFloat64T
string
Copies a string from pfrom to pEpicsString.
array
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 EpicsArray
epicsStruct
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 EpicsStruct The structure must not contain any unknown field types.
epicsMDArray
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 EpicsMDArray

DbdStructLifetime and DbdRecordLifetime

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

DbdLinkSupport

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.

DbdRecordSupport

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.


DbdUserFieldHandler

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.

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.

Retrieved from "https://wiki-ext.aps.anl.gov/epics/index.php?title=V4_Design:_dbdClass&oldid=260"