name: ProductionRuleTokenType

synopsis:

 
g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_mmedia.a

#include <ProductionRuleTokenType.h>

bool setType(ProductionRuleTokenType::TYPE);
ProductionRuleTokenTypeTokenType::TYPE getType();

quick start:

ProductionRuleTokenType prtt;
prtt.setType(ProductionRuleTokenType::NON_TERMINAL);

description:

This is a helper class for ProductionRule. This class, along with a String value and a floating point weight, forms the basis of the linked list of which a ProductionRule is composed. Cases of explicit instantiation outside of the ProductionRule class should be rare; a ProductionRule is typically constructed with on-the-fly instantiation of this class. For example:

ProductionRule prdrl;
prdrl.setRuleName(L"A");
prdrl.append(ProductionRuleTokenType::NON_TERMINAL, L"a");
prdrl.append(ProductionRuleTokenType::KLEENE_STAR);

dependencies:

public constants:

define the class name:

static const String ProductionRuleTokenType::CLASS_NAME = L"ProductionRuleTokenType";

define i/o constants:

static const String ProductionRuleTokenType::DEF_PARAM = L"";

static const long ProductionRuleTokenType::DEF_TAG = 0;

static const String ProductionRuleTokenType::PARAM_TYPE = L"type";

static const String ProductionRuleTokenType::BLOCK_START_STR = L"{";

static const String ProductionRuleTokenType::BLOCK_DELIM_STR = L"}, {";

static const String ProductionRuleTokenType::BLOCK_END_STR = L"}";

static const String ProductionRuleTokenType::BLOCK_TERM_STR = L";\n";

error codes:

protected data:

declare a TYPE field
```
ProductionRuleTokenType::TYPE type_d;
```
declare the debug level
```
DebugLevel debug_level_d;
```

required public methods:

static methods:

static const String& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods:

boolean setDebug(Integral::DEBUG debug_level);

boolean debug(const unichar* msg) const;

constructor:
```
ProductionRuleTokenType();
```

i/o methods:

boolean read(Sof& sof, long tag, const String& cname = CLASS_NAME);

boolean readData(Sof& sof, const String& pname = DEF_PARAM, long size = SofParser::FULL_OBJECT, boolean param = true, boolean nested = false);

boolean write(Sof& sof, long tag, const String& cname = CLASS_NAME) const;

boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;

long sofSize() const;

assign methods:

boolean assign(const ProductionRuleTokenType& prdrl_a);

operator= methods:

ProductionRuleTokenType& operator=(const ProductionRuleTokenType& prdrl_a);

equality methods:

boolean eq(const ProductionRuleTokenType& prdrl_a) const;

operator== methods:

ProductionRuleTokenType& operator==(const ProductionRuleTokenType& prdrl_a);

clear methods:
```
boolean clear(Integral::CMODE ctype);
```

class-specific public methods:

get method:
```
ProductionRuleTokenType getType();
```

set methods:

bool setType(ProductionRuleTokenType::TYPE);

bool setType(const String& type_a);

examples:

This example shows how create a ProductionRuleTokenType for "A::=(a B)+" and retrieve the string representation. This exhibits on-the-fly ProductionRuleTokenType object instantiation.


// declare the ProductionRuleTokenType
//
ProductionRuleTokenType prdrl;

// set the name
//
prdrl.setRuleName(L"A");

// construct the RHS
//
prdrl.append(ProductionRuleTokenTypeTokenType::OPEN_PAREN);
prdrl.append(ProductionRuleTokenTypeTokenType::TERMINAL, L"a");
prdrl.append(ProductionRuleTokenTypeTokenType::CONCATENATION);
prdrl.append(ProductionRuleTokenTypeTokenType::NON_TERMINAL, L"B");
prdrl.append(ProductionRuleTokenTypeTokenType::CONCATENATION);
prdrl.append(ProductionRuleTokenTypeTokenType::KLEENE_PLUS);

// output the string representation of the rule
//
Console::put(prdrl.getRule());

notes: