Record.h

Classes

Record -- A hierarchical collection of named fields of various types (full description)

class Record : public RecordInterface

Interface

Public Members
Record()
explicit Record (RecordType type, CheckFieldFunction* = 0, const void* checkArgument = 0)
explicit Record (const RecordDesc& description, RecordType type = Fixed, CheckFieldFunction* = 0, const void* checkArgument = 0)
Record (const Record& other)
Record (const RecordInterface& other)
Record& operator= (const Record& other)
~Record()
virtual RecordInterface* clone() const
virtual void assign (const RecordInterface& that)
virtual const String& comment (const RecordFieldId&) const
virtual void setComment (const RecordFieldId&, const String& comment)
const RecordDesc& description() const
virtual void restructure (const RecordDesc& newDescription, Bool recursive = True)
Bool conform (const Record& other) const
virtual uInt nfields() const
virtual Int fieldNumber (const String& fieldName) const
virtual DataType type (Int whichField) const
void removeField (const RecordFieldId&)
void renameField (const String& newName, const RecordFieldId&)
void defineRecord (const RecordFieldId&, const Record& value, RecordType type = Variable)
virtual void defineRecord (const RecordFieldId&, const RecordInterface& value, RecordType = Variable)
const Record& subRecord (const RecordFieldId&) const
Record& rwSubRecord (const RecordFieldId&)
virtual const RecordInterface& asRecord (const RecordFieldId&) const
virtual RecordInterface& asrwRecord (const RecordFieldId&)
ValueHolder asValueHolder (const RecordFieldId&) const
void defineFromValueHolder (const RecordFieldId&, const ValueHolder&)
void mergeField (const Record& other, const RecordFieldId&, DuplicatesFlag = ThrowOnDuplicates)
void merge (const Record& other, DuplicatesFlag = ThrowOnDuplicates)
friend AipsIO& operator<< (AipsIO& os, const Record& rec)
friend AipsIO& operator>> (AipsIO& os, Record& rec)
void putRecord (AipsIO& os) const
void getRecord (AipsIO& os)
void putData (AipsIO& os) const
void getData (AipsIO& os, uInt version)
virtual void makeUnique()
Protected Members
virtual void* get_pointer (Int whichField, DataType type) const
virtual void* get_pointer (Int whichField, DataType type, const String& recordType) const
const RecordRep& ref() const
RecordRep& rwRef()
virtual void addDataField (const String& name, DataType type, const IPosition& shape, Bool fixedShape, const void* value)
virtual void defineDataField (Int whichField, DataType type, const void* value)
Private Members
virtual RecordDesc getDescription() const
Record (RecordRep* parent, const RecordDesc& description)
Record (RecordRep* parent, RecordType type)

Description

Review Status

Reviewed By:
Mark Wieringa
Date Reviewed:
1996/04/15
Programs:
Tests:

Prerequisite

Etymology

``Record'' is a widely used term in both programming languages and data structures to denote an imhogeneous set of fields. An alternative would have been to name it structure, which would have perhaps been a clearer name for C++ programmers.

Synopsis

Class RecordInterface decribes the fundamental properties of records.
The Record class is a particular type of a record class. The fields in Record may be of scalar type, array type, or a Record. The types are chosen to be compatible with the native types of the Table system, viz: Bool, uChar, Short, Int, uInt, float, double, Complex, DComplex, String. Arrays of all these types are also available. Note that a Record is not a space-efficient way of storing small objects.

The structure of a Record is defined by the RecordDesc class. The structure of the Record can be defined at construction time. It can thereafter be restructured. This has the effect, however, that any existing RecordFieldPtr objects become invalid (using the Notice classes).
It is possible to add or remove fields once a Record is constructed. However, this is not possible when the Record is constructed with a fixed structure (i.e. with the fixedStructure flag set).

A Record is an hierarchical structure, because it can have fields containing Record's (as layed out in the RecordDesc). A subrecord has a variable structure, when its RecordDesc is empty (i.e. contains no fields). It is fixed when its RecordDesc contains fields.

A Record may be assigned to another only if they conform; that is if their fields have the identical type in the identical order. The field names do not need to be identical however, only the types. That is, the structure needs to be identical, but not the labels. Note that field order is significant, [ifield(type=Int),ffield(type=float)] is not the same as [ffield(type=float),ifield(type=Int)]
Conformance is checked recursively for fixed subrecords. That is, a variable structured subrecord is not checked, because any record can be assigned to it. A fixed structured subrecord has to conform the corresponding subrecord in the source.

Record uses copy-on-write semantics. This means that when a Record is copied, only the pointer to the underlying RecordRep object is copied. Only when the Record gets changed (i.e. when a non-const Record member function is called), the RecordRep object is copied. This results in a cheap copy behaviour.

Example

Suppose we wanted to create a records that describe the favorite example of the OO world - an employee:
    RecordDesc employeeDesc;
    employeeDesc.addField ("name", TpString);
    employeeDesc.addField ("salary", TpDouble);
    
The above creates the description (structure) for some record objects.
    Record employeeA(employeeDesc);
    Record employeeB(employeeDesc, False);
    
And these two lines create Record objects which share this common structure. The first Record has a fixed structure, the 2nd variable.
    RecordFieldPtr<String> nameA(employeeA, 0);
    RecordFieldPtr<String> nameB(employeeB, 0);
    RecordFieldPtr<double> salaryA(employeeA, 1);
    RecordFieldPtr<double> salaryB(employeeB, "salary");
    
This shows how we can get access to the individual fields. The fields are fundamentally identified by number, but the number can be looked up through the use of the fieldNumber member function.
    nameA.define ("Tim");
    nameB.define ("Brian");
    salaryA.define (1.0e+8);
    salaryB.define (1.0 / *salaryA);
    
Once obtained, the fields are readily manipulated, as shown above. Note that the field values are obtained through the dereference (*) operator. This is to identify that the field objects are pointers to the values in the underlying Record; that is
    salaryA = salaryB;
    *salaryA = *salaryB;
    
Do very different things; the first line is a pointer copy; salaryA and salaryB now point to the same field in salaryB. The second line is a value copy.

Whole records can be copied as long as their structures are compatible, so that employeeA = employeeB is a legal statement. However, if the structure is changed, assignment is no longer possible, and all of the field pointers are invalidated:

    employeeB.define ("age", (Int)40);
    employeeA = employeeB;                // exception - no longer conformant

Motivation

Collections of data with different types are frequently needed. Record makes it possible to hold such data in a flexible way.

To Do

Member Description

Record()

Create a record with no fields. The record has a variable structure.

explicit Record (RecordType type, CheckFieldFunction* = 0, const void* checkArgument = 0)

Create a record with no fields. The type determines if the record has a fixed or variable structure. The callback function is called when a field is added to the Record. That function can check the name and of data type of the new field (for instance, the Table system uses it to ensure that table columns and keywords have different names).

explicit Record (const RecordDesc& description, RecordType type = Fixed, CheckFieldFunction* = 0, const void* checkArgument = 0)

Create a record with the given description. If it is not possible to create all fields (for example, if a field with an unsupported data type is requested), an exception is thrown. The type determines if the record has a fixed or variable structure. All fields are checked by the field checking function (if defined) (for instance, the Table system uses it to ensure that table columns and keywords have different names).

Record (const Record& other)

Create a copy of other using copy semantics.

Record (const RecordInterface& other)

Create a Record from another type of record using copy semantics. Subrecords are also converted to a Record.

Record& operator= (const Record& other)

Copy the data in the other record to this record. It can operate in 2 ways depending on the Record structure flag.

Warning Attributes like fixed structure flag and check function will not be copied.

~Record()

Release resources associated with this object.

virtual RecordInterface* clone() const

Make a copy of this object.

virtual void assign (const RecordInterface& that)

Assign that RecordInterface object to this one. Unlike operator= it copies all data in the derived class.

virtual const String& comment (const RecordFieldId&) const

Get the comment for this field.

virtual void setComment (const RecordFieldId&, const String& comment)

Set the comment for this field.

const RecordDesc& description() const

Describes the current structure of this Record.

virtual void restructure (const RecordDesc& newDescription, Bool recursive = True)

Change the structure of this Record to contain the fields in newDescription. After calling restructure, description() == newDescription. Any existing RecordFieldPtr objects are invalidated (their isAttached() members return False) after this call.
When the new description contains subrecords, those subrecords will be restructured if recursive=True is given. Otherwise the subrecord is a variable empty record. Subrecords will be variable if their description is empty (i.e. does not contain any field), otherwise they are fixed. The 2nd form of the restructure function will overwrite those implicit record types with the given record type. The new type will also be given to this top record.
Restructuring is not possible and an exception is thrown if the Record has a fixed structure.

Bool conform (const Record& other) const

Returns True if this and other have the same RecordDesc, other than different names for the fields. That is, the number, type and the order of the fields must be identical (recursively for fixed structured sub-Records in this).

Caution thisRecord.conform(thatRecord) == True does not imply
thatRecord.conform(thisRecord) == True, because a variable record in one conforms a fixed record in that, but not vice-versa.

virtual uInt nfields() const

How many fields does this structure have? A convenient synonym for description().nfields().

virtual Int fieldNumber (const String& fieldName) const

Get the field number from the field name. -1 is returned if the field name is unknown.

virtual DataType type (Int whichField) const

Get the data type of this field.

void removeField (const RecordFieldId&)

Remove a field from the record.

Caution Removing a field means that the field number of the fields following it will be decremented. Only the RecordFieldPtr's pointing to the removed field will be invalidated.

void renameField (const String& newName, const RecordFieldId&)

Rename the given field.

void defineRecord (const RecordFieldId&, const Record& value, RecordType type = Variable)
virtual void defineRecord (const RecordFieldId&, const RecordInterface& value, RecordType = Variable)

Define a value for the given field containing a subrecord. When the field is unknown, it will be added to the record. The second version is meant for any type of record (e.g. Record, TableRecord, GlishRecord). It is converted to a Record using the Record constructor taking a RecordInterface object.

const Record& subRecord (const RecordFieldId&) const
Record& rwSubRecord (const RecordFieldId&)
virtual const RecordInterface& asRecord (const RecordFieldId&) const
virtual RecordInterface& asrwRecord (const RecordFieldId&)

Get the subrecord from the given field. The non-const version has a different name to prevent that the copy-on-write mechanism makes a copy when not necessary.

ValueHolder asValueHolder (const RecordFieldId&) const
void defineFromValueHolder (const RecordFieldId&, const ValueHolder&)

Get or define the value as a ValueHolder. This is useful to pass around a value of any supported type.

void mergeField (const Record& other, const RecordFieldId&, DuplicatesFlag = ThrowOnDuplicates)

Merge a field from another record into this record. The DuplicatesFlag (as described in RecordInterface) determines what will be done in case the field name already exists.

void merge (const Record& other, DuplicatesFlag = ThrowOnDuplicates)

Merge all fields from the other record into this record. The DuplicatesFlag (as described in RecordInterface) determines what will be done in case a field name already exists. An exception will be thrown if other is the same as this (i.e. if merging the record itself).

friend AipsIO& operator<< (AipsIO& os, const Record& rec)

Write the Record to an output stream.

friend AipsIO& operator>> (AipsIO& os, Record& rec)

Read the Record from an input stream.

void putRecord (AipsIO& os) const

Write the Record to an output stream. This is used to write a subrecord, whose description has not been written.

void getRecord (AipsIO& os)

Read the Record from an input stream. This is used to read a subrecord, whose description has not been read.

void putData (AipsIO& os) const

Put the data of a record. This is used to write a subrecord, whose description has already been written.

void getData (AipsIO& os, uInt version)

Read the data of a record. This is used to read a subrecord, whose description has already been read.

virtual void makeUnique()

Make a unique record representation (to do copy-on-write in RecordFieldPtr).

virtual void* get_pointer (Int whichField, DataType type) const
virtual void* get_pointer (Int whichField, DataType type, const String& recordType) const

Used by the RecordField classes to attach in a type-safe way to the correct field.

const RecordRep& ref() const

Return a const reference to the underlying RecordRep.

RecordRep& rwRef()

Return a non-const reference to the underlying RecordRep. When needed, the RecordRep will be copied and all RecordField objects will be notified.

virtual void addDataField (const String& name, DataType type, const IPosition& shape, Bool fixedShape, const void* value)

Add a field to the record.

virtual void defineDataField (Int whichField, DataType type, const void* value)

Define a value in the given field.

virtual RecordDesc getDescription() const

Get the description of this record.

Record (RecordRep* parent, const RecordDesc& description)
Record (RecordRep* parent, RecordType type)

Create Record as a subrecord. When the description is empty, the record has a variable structure. Otherwise it is fixed.