name: NGramNode

synopsis:


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

#include <NGramNode.h>

boolean setIndex(const long index);
boolean setLmScore(const float lm_score);
boolean setBackoff(const float backoff);
boolean setNextGram(HashTable<Long, NGramNode>* hash);
boolean set(const float lm_score, const float backoff);
long getIndex() const;
float getLmScore() const;
float getBackoff() const;
HashTable<Long, NGramNode>* getNextGram() const;

quick start:


NGramNode nnode_00;
HashTable ht1;

nnode_00.setNextGram(ht1);

description:

This class stores the N-gram probability.

dependencies:

HashTable.h

public constants:

define the class name:
```
static const String CLASS_NAME;
```

define i/o related constants:

static const String PARAM_INDEX;

static const String PARAM_LM_SCORE;

static const String PARAM_BACKOFF;

static const String PARAM_NEXT_GRAM;

static const String PARAM_KEYS;

static const String PARAM_VALUES;

static const String DEF_PARAM;

define default values and arguments:

static const long DEF_INDEX;

static const float DEF_LM_SCORE;

static const float DEF_BACKOFF;

error codes:

error codes indicating general errors:
```
static const long ERR = (long)50700;
```

protected data:

declare symbol string represented in this node:

Long index_d;

declare language model and backoff score information:

Float lm_score_d;

declare the backoff weight:

Float backoff_d;

declare a pointer to the next order ngram hash table:

HashTable<Long, NGramNode>* next_gram_d;

declare the debugging parameters:
```
static Integral::DEBUG debug_level_d;
```
declare the memory manager:
```
static MemoryManager mgr_d;
```

required public methods:

static methods:
```
static const String& name();
```

debug methods:

static boolean diagnose(Integral::DEBUG debug_level);

boolean debug(const unichar* msg) const;

destructor/constructor(s):

~NGramNode();

NGramNode();

NGramNode(const NGramNode& arg);

assign methods:
```
boolean assign(const NGramNode& arg);
```

operator= method:

NGramNode& operator= (const NGramNode& arg);

i/o methods:

long sofSize() const;

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

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

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

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

equality methods:
```
boolean eq(const NGramNode& arg) const;
```

memory management methods:

static void* operator new(size_t size);

static void* operator new[](size_t size);

static void operator delete(void* ptr);

static void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

boolean clear(Integral::CMODE ctype = Integral::DEF_CMODE);

class-specific public methods:

declare index methods:

boolean setIndex(const long index);

long getIndex() const;

declare score methods:

boolean setLmScore(const float lm_score);

float getLmScore() const;

declare backoff methods:

boolean setBackoff(const float backoff);

float getBackoff() const;

declare ngram manipulation methods:

boolean set(const float lm_score, const float backoff);

boolean setNextGram(HashTable<Long, NGramNode>* hash);

HashTable<Long, NGramNode>* getNextGram() const;

private methods:

declare private methods:

examples:

none.

notes:

none.