V4 Design: dbdClass

EPICS: C++ class definitions for Database Definition

May 17 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
  • struct
  • menu
• does not include the header files.

The following headers files are described:

• epicsTypes.h - A set of primitive types that are part of base/src/libCom
• dbdTypes.h - Type definitions for non-primitive <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.

---

epicsTypes

epicsTypes.h

epicsTypes.h defines a set of primitive tupes. It is used because the C99 standard does not define the exact number of bits for the primitive data types. It only defines the minimum number of bits.

In addition two extra types are defined:

• epicsUnknownT - Unknown
• epicsOctetT - An 8 bit byte.

epicsTypes.h contains the following:

enum epicsType {
    epicsUnknownT,
    epicsBooleanT,
    epicsOctetT,
    epicsInt16T,
    epicsUInt16T,
    epicsInt32T,
    epicsUInt32T,
    epicsInt64T,
    epicsUInt64T,
    epicsFloat32T,
    epicsFloat64T,
};

/* some of the following may require OSD definitions*/
typedef bool               epicsBoolean;
typedef char               epicsOctet;
typedef short              epicsInt16;
typedef unsigned short     epicsUInt16;
typedef int                epicsInt32;
typedef unsigned int       epicsUInt32;
typedef long long          epicsInt64;
typedef unsigned long long epicsUInt64;
typedef float              epicsFloat32;
typedef double             epicsFloat64;

Discussion of epicsTypes

The types epicsBoolean, epicsOctet, epicsInt16, epicsUInt16, epicsInt32, epicsUInt32, epicsInt64, epicsUInt64, epicsFloat32, epicsFloat64 all map to a C or C++ primitive type. It may be necessary to provide operating system dependent definitions for some of the types. For example on some architectures a epicsInt64 may have to be defined as a long rather than a long long.

If a record is defined as:

    record(xxx) extends iocRecord {
        ...
        field(fbool,bool)
        field(foctet,octet)
        ...
        field(ffloat64,float64)
        ...
    }

Then the generated header file will be

    class xxxRecord : iocRecord {
    public:
        epicsBoolean fbool;
        epicsOctet   foctet;
        ...
        epicsFloat64 ffloat64;
        ...
   };

epicsType epicsTypeUnknownT is reserved for unknown types and will normally be cause by some configuration error.

---

dbdTypes

dbdTypes.h

File dbdTypes.h describes the non-primitive types used by V4 databases: The following naming conventions are used:

Dbf

any class starting with Dbf describes a struct or record field. For example DbfString describes a field(name,string).

*Dbd*

A class name that has Dbd imbeded in it describes something directly related to a dbd statement. For example LinkDbdSupport describes a dbd link definition.

dbdTypes.h contains the following:

1. include <epicsTypes.h>

enum dbdType {
    dbdUnknownT = epicsUnknownT,
    dbdBooleanT = epicsBooleanT,
    dbdOctetT = epicsOctetT,
    dbdInt16T = epicsInt16T,
    dbdUInt16T = epicsUInt16T,
    dbdInt32T = epicsInt32T,
    dbdUInt32T = epicsUInt32T,
    dbdInt64T = epicsInt64T,
    dbdUInt64T = epicsUInt64T,
    dbdFloat32T = epicsFloat32T,
    dbdFloat64T = epicsFloat64T,
    DbfStringT,
    dbdStructT,
    DbfArrayT,
    // dbdNdimArrayT not yet defined
    dbdEnumT,
    dbdMenuT,
    dbdLinkT,
    dbdDeviceT
};

/*DbfString holds UTF-8 characters*/
class DbfString {
public:
    dbdInt32  capacity;  /*capacity in bytes*/
    dbdOctet  *pstorage;
};

// FieldDbdPtr is the address of a dbdType
typedef void *FieldDbdPtr;
// StructDbd is base class for classes implementing struct
class StructDbd {};

// Interface is base class for an interface
class Interface {};
class InterfaceLocator {
public:
    DbfString name;
    Interface *pinterface;
};

// The following are described  in dbdStatements.h
class StructDbdDef; //describes a dbd struct definition
class MenuDbdDef; //describes a dbd menu definition
class LinkDbd;    //describes dbd link statement
class DeviceDbd;  //describes dbd device statement

class DbfStruct{
public:
    StructDbdDef *pstructDef;
    StructDbd    *pstruct; // address of storage
};

template< class ARR_T > class DbfArray {
public:
    dbdInt32  capacity;  /*capacity in number of elements*/
    dbdInt32  size;      /*current number of elements*/
    dbdType   type;
    ARR_T     *pstorage;
};

/*  The following array types are supported by dbdCore
 *  DbfArray<void>;
 *  DbfArray<dbdOctet>;
 *  DbfArray<dbdInt16>;
 *  DbfArray<dbdUInt16>;
 *  DbfArray<dbdInt32>;
 *  DbfArray<dbdUInt32>;
 *  DbfArray<dbdInt64>;
 *  DbfArray<dbdUInt64>;
 *  DbfArray<dbdFloat32>;
 *  DbfArray<dbdFloat64>;
 *  DbfArray<DbfString>;
 *  DbfArray<dbdLinkField>;
**/

class DbfMenu{
public:
    dbdInt16    index;
    MenuDbdDef  *pmenuDef; /* address of global menu */
};

class DbfEnum{
public:
    dbdInt16  index;
    MenuDbdDef *pmenuDef; /* address of record instance menu */
};

enum LinkDir {
    LinkDirNone,
    LinkDirForward,
    LinkDirIn,
    LinkDirOut,
    LinkDirInOut
};

class DbfLink{ 
public:
    LinkDir   dir;
    LinkDbd   *plinkDef;
    DbfStruct dataStruct;
};

class DbfDevice{
public:
    LinkDir   dir;
    DeviceDbd *pdeviceDef;
    DbfStruct dataStruct;
};

Discussion of dbdTypes

Primitive Types

The types dbdBoolean, dbdOctet, dbdInt16, dbdUInt16, dbdInt32, dbdUInt32, dbdInt64, dbdUInt64, dbdFloat32, dbdFloat64 all map to an epicsType.

DbfString

DbfString is described as:

    class DbfString {
    public:
        dbdInt32  capacity;  /*capacity in bytes*/
        dbdOctet  *pstorage;
    };

If a record definition contains

    field(sfield,string)

Then the generated header file contains

    DbfString sfield;

pstoragewill always be the address of a UTF-8 null terminated character string. The capacity is the the number of bytes referenced by pstorage NOT the number of characters.

A support library and rules must be created for managing DbfStrings.

DbfStruct

DbfStruct> is described as:

    class DbfStruct{
    public:
        StructDbdDef *pstructDef;
        StructDbd    *pstruct; // address of storage
    };

If a record definition contains

    field(sstruct,struct(name))

Then the generated header file contains

    DbfStruct sfield;

pstruct is the address of storage for the structure and pstructDef is the address of a description of the structure. StructDbdDef is described in dbdStatatements.h

Note that given a dbdStruct it is possible to locate both the address and description of the associated structure.

DbfArray

Discussion needed. Note that multi-dimensional arrays must also be described.

DbfMenu

dbdMenu> is described as:

    class DbfMenu{
    public:
        dbdInt16    index;
        MenuDbfDef  *pmenuDef;
    };

If a record definition contains

    field(fmenu,menu(name))

Then the generated header file contains

    DbfMenu fmenu;

The definition of dbdMenu provides the current menu index and also the menu definition.

DbfEnum

DbfEnum> is described as:

    class DbfEnum{
    public:
        dbdInt16  index;
        MenuDbdDef *pmenuDef; /* address of record instance menu */
    };

If a record definition contains

    field(fenum,enum)

Then the generated header file contains

    DbfEnum fenum;

Note that the definition of DbfEnum looks identical to DbfMenu. The difference is that DbfMenu has the address of a global MenuDbfDef but DbfEnum has the addrsss of a MenuDbfDef that belongs to the record instance.

DbfLink

DbfLink is described as

    class DbfLink{ 
    public:
        LinkDir   dir;
        LinkDbd   *plinkDef;
        DbfStruct 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 LinkDbd definition and is the most restrictive. For example if one says inout and the other says in then dir will be in.

choiceName

The record instance specifies this and it is used to locate the associated dbd link definition.

plinkDef

This is the address of the LinkDbd.

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 LinkDbdSupport

dbdDevice

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

---

dbdStatements

dbdStatements.h

dbdStatements.h contains the following:

class StructFieldAttribute {
    DbfString  default;
    dbdBoolean readonly;
    dbdBoolean design;
    dbdBoolean special;
    dbdBoolean dynamic;
    epicsInt16 asl;
};

class StructDbdField {
public:
    DbfString name;
    dbdType   type;
    StructFieldAttribute *pattribute;
};

class StructDbdDef{
public:
    DbfString    name;
    Interface    *plifetime; // references a StructDbdLifetime
    dbdInt16     nfields;
    StructDbdField *pfields[]; // ptr to array of ptr to StructDbdField
};

class MenuDbdChoice {
    DbfString choiceName;
    DbfString menuName;
}

class MenuDbdDef{
public:
    DbfString name;
    dbdInt16  nchoices;
    MenuDbdChoice *pchoice[];
};

class LinkDbd{ //describes dbd link statement
public:
    LinkDir    dir;
    DbfString  choiceName;
    DbfString  dataStructName;
    Interface  *pinterface;
};

class DeviceDbd { //describes dbd device statement
public:
    LinkDir   dir;
    DbfString interfaceName;
    DbfString choiceName;
    DbfString dataStructName;
    Interface *pinterface;
};

// The following describes record types and record instances
class UserDbdField;
class userFieldHandler {
public:
    virtual bool initialize(dbfString *errorMessage,
                     iocRecord *precord,UserDbdField *puserField) = 0;
    virtual bool finalize(dbfString *errorMessage,
                     iocRecord *precord,UserDbdField *puserField) = 0;
    virtual bool process(dbfString *errorMessage,
                     iocRecord *precord,UserDbdField *puserField) = 0;
};

class UserDbdField {
public:
    dbfString   name;
    dbfType     type;
    FieldDbdPtr pfield;
    InterfacePtr *pinterface; // references userFieldHandler
}

class RecordDbdField {
public:
    dbfString name;
    dbfType   type;
};

class RecordDbd { // describes a record type
    dbfArray< UserDbdField > userField;
    dbfArray< RecordDbdField > recField;
    Interface    *plifetime; // references a StructDbdLifetime
}

Discussion of dbdStatements

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

= Struct

The Struct classes describe the fields in a dbd struct or record definition. The classes are : StructDbdDef, StructDbdField,and StructFieldAttribute The fields of StructDbdDef are:

name

The name of the struct.

plifetime

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

nfields

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

pfields

pointer to an array of pointers to StructDbdField. Each StructDbdField contains the name and type of the fields.

The fields of StructDbdField are:

name

The name of the field

type

The dbfType for the field.

pattribute

The address of a StructFieldAttribute for the field

The fields of StructFieldAttribute show the falue of the attributes for the field.

= Menu

A dbd menu is described by the classes: MenuDbdDef and MenuDbdChoice

The fields of MenuDbdDef are:

name

The menu name.

nchoices

The number of menu choices.

pchoice

The address of an array of pointers to choices

The fields of MenuDbdChoice described a single choice:

choiceName

The choice name, i.e. the C++ variable name that appears in the generated enum statement for the menu

menuName

The menu choice that DCTs and the value returned when the menu choice strings are requested.

Link and Device

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

dir

The link direction

choiceName

The name that to find a LinkDbd for a DbfLink instance.

dataStructName

The class name of a DbfStruct for the Interface implementation

pinterface

The address of the Interface implementation. The interface class is LinkDbdSupport

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

dir

The link direction

interfaceName

The name of the interface class implemented by the device support

choiceName

The name that to find a LinkDbd for a DbfLink instance.

dataStructName

The class name of a DbfStruct for the Interface implementation

pinterface

The address of the Interface implementation. The interface class is LinkDbdSupport

---

dbdInterfaces.h

dbdInterfaces.h

dbdInterfaces.h contains the following:

// every struct and every record support module implements the following
// The implementation is generated from the dbd definition
class StructDbdLifetime {
public:
    virtual StructDbdPtr create() = 0;
    virtual bool initialize(dbfString *errorMessage,
                             StructDbdPtr ptr) = 0;
    virtual bool finalize(dbfString *errorMessage,
                             StructDbdPtr ptr) = 0;
    virtual void destroy(StructDbdPtr ptr) = 0;
    virtual void *indexToAddr(dbfString *errorMessage,
                             StructDbdPtr ptr, dbfInt16 index) = 0;
    // ???? is anything else needed
};

// every link support module implements the following interface
class LinkDbdSupport {
public:
    virtual void report(dbfString *errorMessage,
                     iocRecord *precord, dbfLink *pdbfLink) = 0;
    virtual bool initialize(dbfString *errorMessage,
                     iocRecord *precord, dbfLink *pdbfLink) = 0;
    virtual bool finalize(dbfString *errorMessage,
                     iocRecord *precord, dbfLink *pdbfLink) = 0;
    virtual bool connect(dbfString *errorMessage,
                     iocRecord *precord, dbfLink *pdbfLink) = 0;
    virtual bool disconnect(dbfString *errorMessage,
                     iocRecord *precord, dbfLink *pdbfLink) = 0;
    virtual bool get(dbfString *errorMessage,
                     iocRecord *precord, dbfLink *pdbfLink,
                     dbfType type, FieldDbdPtr pfield) = 0;
    virtual bool put(dbfString *errorMessage,
                     iocRecord *precord, dbfLink *pdbfLink,
                     dbfType type, FieldDbdPtr pfield) = 0;
};

/* record support implements the following*/
class RecordDbdSupport {
public:
    virtual iocRecord *create(dbfString *errorMessage) = 0;
    virtual bool destroy(dbfString *errorMessage, iocRecord *precord) = 0;
    virtual bool init(dbfString *errorMessage,
                     iocRecord *precord, bool firstPass) = 0;
    virtual void special(iocRecord *precord, iocRecord *precord,
            bool  after,
            dbfInt16 nlevels, // number of elements in fieldIndex
            dbfInt16 fieldIndex[] // array of field indices
            ) = 0;
};

Discussion of dbdInterfaces

StructDbdLifetime

Every dbd struct and record has an associated StructDbdLifetime interface implementation. A tool is provided that automatically generates the implementation form the dbd definition. StructDbdLifetime is described as:

    class StructDbdLifetime {
    public:
        virtual StructDbdPtr create() = 0;
        virtual bool initialize(dbfString *errorMessage,
                                 StructDbdPtr ptr) = 0;
        virtual bool finalize(dbfString *errorMessage,
                                 StructDbdPtr ptr) = 0;
        virtual void destroy(StructDbdPtr ptr) = 0;
        virtual void *indexToAddr(dbfString *errorMessage,
                                 StructDbdPtr ptr, dbfInt16 index) = 0;
        // ???? is anything else needed
    };

where:

create

Creates storage for the struct or record.

initialize

initializes the struct or record

finalize

cleans up but does not free storage

destroy

frees storage

indexToAddr

Given an index it returns the address of the storage. Note the the generated header files assign an index to each field.

LinkDbdSupport

Not yet described

RecordDbdSupport

Not yet described

---

Example of Generated Header Files

Database Definition Files

menuAlarmSevr.dbd contains:

    menu(menuAlarmSevr) { 
         choice(menuAlarmSevrNO_ALARM,"NO_ALARM") 
         choice(menuAlarmSevrMINOR,"MINOR")
         choice(menuAlarmSevrMAJOR,"MAJOR")
         choice(menuAlarmSevrINVALID,"INVALID")
    }

displayLimit.dbd contains:

    struct(displayLimit) {
        field(low,float64)
        field(high,float64)
    }

exampleRecord.dbd contains:

    record(example) extends iocRecord {
        field(value,float64)
        field(displayLimit,struct(displayLimit))
    }

alltypesRecord.dbd contains:

    record(allTypes) extends iocRecord {
        field(fbool,bool)
        field(foctet,octet)
        field(fint16,int16)
        field(fuint16,uint16)
        field(fint32,int32)
        field(fuint32,uint32)
        field(fint64,int64)
        field(fuint64,uint64)
        field(ffloat32,float32)
        field(ffloat64,float64)
        field(fstring,string)
        field(fmenu,menu(menuName))
        field(fenum,enum)
        field(fstruct,struct(displayLimit))
        field(flink,link(dir))
        field(fdevice,device(dir,interfaceName))
    }

Generated Header Files

Tools are provided to generate header files from the following dbd definitions:

• menu
• struct
• record

menuAlarmSevr.h is generated from menuAlarmSevr.dbd

    enum menuAlarmSevr {
           menuAlarmSevrNO_ALARM,
           menuAlarmSevrMINOR,
           menuAlarmSevrMAJOR,
           menuAlarmSevrINVALID
    };

displayLimit.h is generated from displayLimit.dbd

    class displayLimit {
    public:
        dbfFloat64 low;
        dbfFloat64 high;
    };
    const dbfInt16 displayLimit_firstIndex = 1
    const dbfInt16 displayLimit_low        = 1
    const dbfInt16 displayLimit_high       = 2
    const dbfInt16 displayLimit_lastIndex =displayLimit_high

exampleRecord.h is generated from exampleRecord.dbd

    class exampleRecord {
    public:
        ...    All the fields from iocRecord.dbd
        dbfFloat64 value;
        dbfStruct  displayLimit;
    };
   
    const dbfInt16 example_firstIndex = 1001001
    const dbfInt16 example_low = 1001001;
    const dbfInt16 example_high = 1001002;
    const dbfInt16 example_lastIndex = example_high;

alltypesRecord.h is generated from alltypesRecord.dbd

    class allTypesRecord {
    public:
        ...    All the fields from iocRecord.dbd
        iocRecord  common;
        dbfBoolean fbool;
        dbfOctet   foctet;
        dbfInt16   fint16;
        dbfUInt16  fuint16;
        dbfInt32   fint32;
        dbfUInt32  fuint32;
        dbfInt64   fint32;
        dbfUInt64  fuint32;
        dbfFloat32 ffloat32;
        dbfFloat64 ffloat64;
        dbfString  fstring;
        dbfMenu    fmenu;
        dbfEnum    fenum
        dbfStruct  fstruct;
        dbfLink    flink;
        dbfDevice  fdevice;
    };
   
    const dbfInt16 allTypes_firstIndex = 1001001
    const dbfInt16 allTypes_fbool = 1001001;
    const dbfInt16 allTypes_foctet = 1001002;
    const dbfInt16 allTypes_fint16 = 1001003;
    const dbfInt16 allTypes_fuint16 = 1001004;
    const dbfInt16 allTypes_fint32 = 1001005;
    const dbfInt16 allTypes_fuint32 = 1001006;
    const dbfInt16 allTypes_fint64 = 1001007;
    const dbfInt16 allTypes_fuint64 = 1001008;
    const dbfInt16 allTypes_ffloat32 = 1001009;
    const dbfInt16 allTypes_ffloatn64 = 10010010;
    const dbfInt16 allTypes_ffstring = 10010011;
    const dbfInt16 allTypes_fmenu = 10010012;
    const dbfInt16 allTypes_fenum = 10010013;
    const dbfInt16 allTypes_fstruct = 10010014;
    const dbfInt16 allTypes_flink = 10010015
    const dbfInt16 allTypes_fdevice = 10010016
    const dbfInt16 allTypes_lastIndex = allTypes_fdevice;

---