Linguistic Classes Example Code

Adding basic information to an EST_Item

An item such as

The type of the values in features is a EST_Val class, which is a union which can store ints, floats, EST_Strings, void pointers, andEST_Features. The overloaded function facility of C++ means that the set() can be used for all of these.

Accessing basic information in an Item

When accessing the features, the type must be specified. This is done most easily by using of a series of functions whose type is coded by a capital letter:

F()

return value as a float

I()

return value as a integer

S()

return value as a

A()

return value as a EST_Features

A optional default value can be given if a result is always desired

Nested feature structures in items

Nested feature structures such as Example 6-1

or by filling the values in an EST_Features object and copying it in:

Nested features can be accessed by multiple calls to the accessing commands:

The first command is A() because PLACE is a feature structure, and the second command is S() because it returns a string (the value or ANTRIOR or CORONAL). A shorthand is provided to extract the value in a single statement:

Again, as the last value to be returned is a string S() must be used. This shorthand can also be used to set the features:

Adding arbitrary classes into items

As well as the built types, of int, float and string, EST_Items can hold any other type, for example a waveform or track. Only pointers to classes can be added - the EST_Val class takes care of garbage collection.

First we must add the ability to have a certain type as a val. This is done by a having the following macro in the appropriate .h file by the following command:

VAL_REGISTER_CLASS_DCLS(wave,EST_Wave)

The first argument (wave) is an artibtrary name which is used to form a function for casting from the val. To add a waveform as a value, the est_val macro must be called to make a value out of the object:

To get a waveform back, the wave casting function must be used:

Utility functions for items

The presence of a attribute can be checked using f_present(), which returns true if the attribute is in the item:

A attirbute can be removed by f_remove

Building a linear list relation

kk It is standard to store the phones for an utterance as a linear list in a EST_Relation object. Each phone is represented by one EST_Item, whereas the complete list is stored as a EST_Relation.

The easiest way to build a linear list is by using the EST_Relation.append(), which when called without arguments, makes a new empty EST_Item, adds it onto the end of the relation and returns a pointer to it. The information relevant to that phone can then be added to the returned item.

Note that the -> operator is used because the EST_Item a is a pointer here. The same pointer variable can be used multiple times because every time append() is called it allocates a new item and returns a pointer to it.

If you already have a EST_Item pointer and want to add it to a relation, you can give it as an argument to append(), but this is generally inadvisable as it involves some unecessary copying, and also you have to allocate the memory for the next EST_Item pointer yourself everytime (if you don't you will overwrite the previous one):

Items can be prepended in exactly the same way:

Iterating through a linear list relation

Iteration in lists is performed with next() and prev(), and an EST_Item, used as an iteration pointer.

head() and tail() return EST_Item pointers to the start and end of the list. next() and prev() returns the next or previous item in the list, and returns 0 when the end or start of the list is reached. Hence checking for 0 is a useful termination condition of the iteration. Taking advantage of C shorthand allows us to write:

Building a tree relation

It is standard to store information such as syntax as a tree in a EST_Relation object. Each tree node is represented by one EST_Item, whereas the complete tree is stored as a EST_Relation.

The easiest way to build a tree is by using the append_daughter(), which when called without arguments, makes a new empty EST_Item, adds it as a daughter to an existing item and returns a pointer to it. The information relevant to that node can then be added to the returned item. The root node of the tree must be added directly to the EST_Relation.

Obviously, the use of recursive functions in building trees is more efficient and would eliminate the need for the large number of temporary variables used in the above example.

Iterating through a tree relation

Iteration in trees is done with daughter1() daughter2() daughtern() and parent(). Pre-order traversal can be achieved iteratively as follows:

A special set of iterators are available for traversal of the leaf (terminal) nodes of a tree:

Building a multi-linear relation

This is not yet fully implemented.

Iterating through a multi-linear relation

This is not yet fully implemented.

The EST_Utterance class is used to store all the items and relations relevant to a single utterance. (Here utterance is used as a general linguistic entity - it doesn't have to relate to a well formed complete linguistic unit such as a sentence or phrase).

Instead of storing relations separately, they are stored in utterances:

EST_Relations can be accessed though the utterance object either directly or by use of a temporary EST_Relation pointer:

The contents of the relation can be filled by the methods described above.

Adding items into multiple relations

A major aspect of this system is that an item can be in two relations at once, as shown in Figure 6-2.

In the following example, using the syntax relation as already created in Example 6-2, shows how to put the terminal nodes of this tree into a word relation:

Thus the terminal nodes in the syntax relation are now stored as a linear list in the word relation. Hence

produces

whereas

produces

Changing the relation an item is in.

Even if an item is in more than one relation, it always has the idea of a "current" relation. If the traversal functions (next, previous, parent etc) are called, traversal always occurs with respect to the current relation. An item's current relation can be changed as follows:

while s is still the same item, the current relation is now "Syntax". The current relation is returned by the relation() function:

If you aren't sure whether an item is in a relation, you can check with in_relation(). This will return true if an item is in the requested relation regardless of what the current relation is.

Feature functions

evaluate functions setting functions