V4 Design: dbdClass - Revision history

MartyKraimer at 19:53, 11 August 2005

2005-08-11T19:53:59Z

MartyKraimer at 20:07, 7 July 2005

2005-07-07T20:07:07Z

← Older revision		Revision as of 20:07, 7 July 2005
Line 1:		Line 1:
	= EPICS: dbdClasses - IOC Database Description =		= EPICS: dbdClasses - IOC Database Description =
	~~June 24~~ 2005		July 07 2005

	----		----
Line 9:		Line 9:
	</center>		</center>

	This document describes the C++ ~~class~~ definitions for code that ~~implements~~		This document describes the C++ definitions for code that accessses
	the ~~semantics for~~ records created from Database Definitions. The definitions		IOC records, i.e. the records created from Database Definitions.
			The definitions
	are intended for code that:		are intended for code that:
	* includes header files generated from dbd definitions. Header files are generated from the following dbd definitions:		* includes header files generated from dbd definitions. Header files are generated from the following dbd definitions:
Line 20:		Line 21:
	This document discusses the following:		This document discusses the following:
	* dbfTypes - Type definitions for <tt>field</tt> definitions in <tt>struct</tt> or <tt>record></tt> DBD definitions.		* dbfTypes - Type definitions for <tt>field</tt> definitions in <tt>struct</tt> or <tt>record></tt> DBD definitions.
	* Database ~~Field Types~~ - The ~~definitions that appear if header files generated from <tt>field</tt> definitions~~.		* Database Fields - The C++ types for database fields.
	* dbdStatements - Structures that describe the <tt>menu, link, device, struct,</tt> and <tt>record</tt> DBD definitions~~. It~~ also ~~the~~ structures that describe record instances.		* dbdStatements - Structures that describe the <tt>menu, link, device, struct,</tt> and <tt>record</tt> DBD definitions, and also structures that describe record instances.
	* Introspection - Class definitions that provide access to database fields and to dbdStatements.		* Introspection - Class definitions that provide access to database fields and to dbdStatements.
	* Field Access - Classes for accessing the ~~vales~~ in database fields.		* Field Access - Classes for accessing the values in database fields.
	* Record and Structure Lifetime - Automatically generated files for <tt>struct</tt> and <tt>record</tt> DBD definitions.		* Record and Structure Lifetime - Automatically generated files for <tt>struct</tt> and <tt>record</tt> DBD definitions.
	* Record Support - The ~~class~~ that must be implemented by record support		* Record Support - The interface that must be implemented by record support
	* User Field Support - The classes associated with user defined fields.		* User Field Support - The classes associated with user defined fields.
	* Link and Device Support - The classes implemented by link and device support		* Link and Device Support - The classes implemented by link and device support
Line 40:		Line 41:
	The following naming conventions are used:		The following naming conventions are used:
	; C++ <tt>struct</tt> vs <tt>class</tt>		; C++ <tt>struct</tt> vs <tt>class</tt>
	: A C++ <tt>class</tt> is used for a class that has methods and <tt>struct</tt> is used for a class that has only data.		: A C++ <tt>class</tt> is used for a class that has methods and <tt>struct</tt> is used for a class that has only data. Most Dbf and Dbd definitions are <tt>struct</tt>. Since records are accessed by many different interfaces, defining these as pure data seems to best. The only exceptions are interface definitions.
	; Dbf		; Dbf
	: any class starting with Dbf describes a field in a generated header file. For example DbfArray describes a field generated from <tt>field(name,array(float64[])</tt>.		: any class starting with Dbf describes a field in a generated header file. For example DbfArray describes a field generated from <tt>field(name,array(float64[])</tt>.
Line 62:		Line 63:
	dbfTypeArray, // DbfArray		dbfTypeArray, // DbfArray
	dbfTypeMDArray // DbfMDArray		dbfTypeMDArray // DbfMDArray
	~~dbfMenuT~~, // DbfMenu		dbfTypeMenu, // DbfMenu
	~~dbfEnumT~~, // DbfEnum		dbfTypeEnum, // DbfEnum
	~~dbfLinkT~~, // DbfLink		dbfTypeLink, // DbfLink
	~~dbfDeviceT~~ // DbfDevice		dbfTypeDevice // DbfDevice
	dbfTypeStruct, // DbfStruct		dbfTypeStruct, // DbfStruct
	};		};

	=== Discussion of dbfTypes ===		=== Discussion of dbfTypes ===

			Question:
			* Should dbfTypeString be EpicsString or should a DbfString be defined?

	DBD type		DBD type
Line 94:		Line 98:
	field(ffloat,float64)		field(ffloat,float64)
	field(fstring,string)		field(fstring,string)
	field(~~array~~,array(double[])		field(farray,array(double[])
	field(~~mdarray~~,array(double[,])		field(fmdarray,array(double[,])
	field(fmenu,menu(name))		field(fmenu,menu(name))
	field(fenum,enum)		field(fenum,enum)
Line 122:		Line 126:
	epicsFloat64 ffloat;		epicsFloat64 ffloat;
	EpicsString fstring;		EpicsString fstring;
	DbfArray ~~array~~;		DbfArray farray;
	DbfMDArray ~~mdarray~~;		DbfMDArray fmdarray;
	DbfMenu fmenu;		DbfMenu fmenu;
	DbfEnum fenum;		DbfEnum fenum;
Line 140:		Line 144:
	<center>		<center>

	== Database ~~Field Types~~ ==		== Database Fields ==
	</center>		</center>

	=== ~~epicsTypes~~ ===		=== Primitive Types ===

	Fields of type epicsBoolean, epicsOctet, epicsInt16, epicsInt32, epicsInt64,		Fields of type epicsBoolean, epicsOctet, epicsInt16, epicsInt32, epicsInt64,
Line 152:		Line 156:
	file. Some examples are:		file. Some examples are:

	~~xxxRecord &record~~;		exampleRecord *precord;
	epicsInt16 myint;		epicsInt16 myint;
	...		...
	~~record.~~ffloat = 10.0		precord->ffloat = 10.0
	...		...
	myint = ~~record.~~fint;		myint = precord->fint;

	Code that does not include the generated header file can access these fields		Code that does not include the generated header file can access these fields
Line 174:		Line 178:
	// NOTE that all modification of fields must also be posted		// NOTE that all modification of fields must also be posted


			=== EpicsString ===

	A field of type EpicsString is initialized via the default constructor for		A field of type EpicsString is initialized via the default constructor for
Line 183:		Line 189:
	and the record support wants to print the string value.		and the record support wants to print the string value.

	~~xxxRecord &record~~;		exampleRecord *precord;
	const epicsOctet *pdata;		const epicsOctet *pdata;
	epicsInt32 len;		epicsInt32 len;
	...		...
	if(~~!record.string~~->expose(0,len,pdata)) {// do something}		if(precord->fstring->expose(0,len,pdata)) {// do something}
	...		...
	printf("%.*s\n",len,pdata);		printf("%.*s\n",len,pdata);
Line 276:		Line 282:
	A field of type DbfEnum is automatically initialized by dbLoadRecords.		A field of type DbfEnum is automatically initialized by dbLoadRecords.

	=== DbfLink and ~~DbdDevice~~ ===		=== DbfLink and DbfDevice ===


Line 303:		Line 309:
	The fields of <tt>DbfLink</tt> are initialized by dbLoadRecords as follows:		The fields of <tt>DbfLink</tt> are initialized by dbLoadRecords as follows:
	; <tt>dir</tt>		; <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.		: 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 <tt>inout</tt> and the other says <tt>in</tt> then <tt>dir</tt> will be <tt>in</tt>.
	; <tt>plinkDef</tt>		; <tt>plinkDef</tt>
	: This is the address of the <tt>DbdLink</tt>.		: This is the address of the <tt>DbdLink</tt>.
Line 327:		Line 333:
	; <tt>pdescription</tt>		; <tt>pdescription</tt>
	: This is initialized via the structure name specified in field definition.		: This is initialized via the structure name specified in field definition.
	; <tt>pstorage		; <tt>pstorage</tt>
	: This is initialized by calling DbdStructLifetime:allocate		: This is initialized by calling DbdStructLifetime:allocate

Line 672:		Line 678:
	DbAddr(EpicsString &recordName, EpicsString &fieldName);		DbAddr(EpicsString &recordName, EpicsString &fieldName);
	virtual ~DbAddr();		virtual ~DbAddr();
	virtual ~~epicsType~~ getType() = 0;		virtual dbfType getType() = 0;
	virtual void *getAddr() = 0;		virtual void *getAddr() = 0;
	virtual DbdRecordInstance *getDbdRecordInstance() = 0;		virtual DbdRecordInstance *getDbdRecordInstance() = 0;
	virtual void getIndex(epicsInt16 nlevels,epicsInt16 paindex) = 0;		virtual void getIndex(epicsInt16 nlevels,epicsInt16 paindex) = 0;

MartyKraimer at 14:17, 24 June 2005

2005-06-24T14:17:20Z

Show changes

MartyKraimer at 13:31, 21 June 2005

2005-06-21T13:31:36Z

Show changes

MartyKraimer at 14:10, 20 June 2005

2005-06-20T14:10:37Z

Show changes

MartyKraimer at 16:04, 17 June 2005

2005-06-17T16:04:34Z

Show changes

MartyKraimer at 18:34, 16 June 2005

2005-06-16T18:34:35Z

← Older revision		Revision as of 18:34, 16 June 2005
Line 178:		Line 178:

	class Int16Array {		class Int16Array {
			public:
	Int16Array(DbfArray *parray);		Int16Array(DbfArray *parray);
	Int16Array(DbfArray *parray,		Int16Array(DbfArray *parray,

MartyKraimer at 12:15, 10 June 2005

2005-06-10T12:15:54Z

← Older revision		Revision as of 12:15, 10 June 2005
Line 134:		Line 134:
	<tt>DbfArray</tt> is:		<tt>DbfArray</tt> is:

	~~struct~~ DbfArray {		class DbfArray {
			public:
	DbfArray(dbfType type = dbfTypeOctet);		DbfArray(dbfType type = dbfTypeOctet);
	DbfArray(const char *bufferType, epicsInt32 capacity,		DbfArray(const char *bufferType, epicsInt32 capacity,

MartyKraimer: Changed DbfArray

2005-06-10T12:14:04Z

Changed DbfArray

← Older revision		Revision as of 12:14, 10 June 2005
Line 1:		Line 1:
	= EPICS: dbdClasses - IOC record =		= EPICS: dbdClasses - IOC record =
	June 9 2005		June 10 2005

	----		----
Line 135:		Line 135:

	struct DbfArray {		struct DbfArray {
	dbfType type;		DbfArray(dbfType type = dbfTypeOctet);
	~~EpicsArray *parray;~~		DbfArray(const char *bufferType, epicsInt32 capacity,
	};		dbfType type = 0);
			DbfArray(DbfBufferCreator *creator, epicsInt32 capacity,
	~~In addition the following convenience classes are available .~~		dbfType type = 0);
			~DbfArray();
	~~class BasicTypeArray {~~		epicsOctet setType(dbfType type);
	~~BasicTypeArray(~~DbfArray *parray);		dbfType getType() const;
	~~BasicTypeArray~~(~~DbfArray *parray,~~
	const char *bufferType, epicsInt32 capacity);
	~~BasicTypeArray~~(~~DbfArray *parray,~~
	~~BufferCreator~~ *creator, epicsInt32 capacity);
	~~virtual~~ ~~~BasicTypeArray~~();
	~~epicsInt32 getElementSize~~() const;
	void useBuffer(const char *bufferType, epicsInt32 capacity = 0);		void useBuffer(const char *bufferType, epicsInt32 capacity = 0);
	void useBuffer(~~EpicsBufferCreator~~ *creator, epicsInt32 capacity = 0);		void useBuffer(DbfBufferCreator *creator, epicsInt32 capacity = 0);
	void destroy();		void destroy();
	~~EpicsBufferCreator~~ *creator() const;		epicsOctet *element(epicsInt32 index);
			const epicsOctet *element(epicsInt32 index) const;
			epicsInt32 get(epicsInt32 offset, epicsInt32 len,
			epicsOctet *pto) const;
			epicsInt32 put(epicsInt32 offset, epicsInt32 len,
			const epicsOctet *pfrom);

			// These are similar to DbfBuffer, measured in elements not octets
			DbfBufferCreator *creator() const;
			void reserve(epicsInt32 capacity);
			epicsInt32 capacity() const;
			void resize(epicsInt32 newsize);
			epicsInt32 size() const;
			epicsInt32 maxSize() const;
	bool mutable() const;		bool mutable() const;
			void expose(epicsInt32 offset, epicsInt32 &len,
			epicsOctet *&pdata);
			void expose(epicsInt32 offset, epicsInt32 &len,
			const epicsOctet *&pdata) const;
	protected:		protected:
	~~DbfArray~~ *parray;		dbfType type;
			EpicsArray *parray;
	private:		private:
	~~BasicTypeArray~~(const ~~EpicsBasicTypeArray~~ &);// No copy constructor		DbfArray(const DbfArray &); // No copy constructor
	~~// No assignment operator~~		DbfArray& operator=(const DbfArray &); // No assignment operator
	~~BasicTypeArray~~& operator=(const ~~EpicsBasicTypeArray~~ &);
	};		};

	class Int16Array ~~: public BasicTypeArray~~ {
			In addition the following convenience classes are available .

			class Int16Array {
	Int16Array(DbfArray *parray);		Int16Array(DbfArray *parray);
	Int16Array(DbfArray *parray,		Int16Array(DbfArray *parray,
Line 187:		Line 201:
	const epicsInt16 *&pdata) const;		const epicsInt16 *&pdata) const;
	private:		private:
			DbfArray *parray;
	Int16Array(const EpicsInt16Array &); // No copy constructor		Int16Array(const EpicsInt16Array &); // No copy constructor
	Int16Array& operator=(const EpicsInt16Array &); // No assignment operator		Int16Array& operator=(const EpicsInt16Array &); // No assignment operator
Line 215:		Line 230:
	<tt>DbfMDArray</tt> is:		<tt>DbfMDArray</tt> is:

	~~struct DbfMDArray {~~
	~~dbfType type;~~
	~~EpicsMDArray *parray;~~
	};

	Need something like for DbfArray except that convenience classes will be		Need something like for DbfArray except that convenience classes will be

MartyKraimer at 19:46, 9 June 2005

2005-06-09T19:46:12Z

Show changes