name: SearchNode

synopsis:

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

#include <SearchNode.h>

~SearchNode();
SearchNode();
SearchNode(const SearchNode& copy_sym);
SearchNode(const String& symbol);

quick start:

#include <SearchNode.h>

SearchNode search_node;

SearchSymbol state_sym_1;
state_sym_1.assign(L"ae_1");

search_node.setSymbol(state_sym_1);

GaussianModel gauss_model;
search_node.setStatisticalModel(&gauss_model);

Trace new_trace;
search_node.addTrace(&new_trace);
search_node.clearTraceList();

description:

The SearchNode class specifies a location in a search space.

dependencies:

public constants:

define the class name:
```
static const String CLASS_NAME;
```
define i/o related constants:
```
static const String DEF_PARAM;
```

define default value(s) of the class data:

static const long DEF_SYMBOL_ID = -1;

static const long DEF_DUMMY_SYMBOL_ID = -100;

static const long DEF_TIMESTAMP = -1;

static const float INACTIVE_SCORE = -11111111111111.0f;

error codes:

error code indicating a general error:
```
static const long ERR = 90300;
```

protected data:

define the symbol that is represented by this node:

 Long symbol_id_d;

define the underlying statistical model for this node:

 StatisticalModel* stat_model_d;

define the level this node exists at in the main graph:

 SearchLevel* level_d;

define the set of traces at this node in the search:

 DoubleLinkedList<Trace> traces_d;

define the current time stamp for this node:

 long timestamp_d;

define the current score:

 float score_d;

define the memory manager:
```
static MemoryManager mgr_d;
```
define the debug level:
```
static Integral::DEBUG debug_level_d;
```

required public methods:

static methods:

static const String& name();

static boolean diagnose(Integral::DEBUG debug_level);

debug methods:

boolean debug(const unichar* message) const;

static boolean setDebug(Integral::DEBUG debug_level);

destructor/constructor(s):

~SearchNode();

SearchNode();

SearchNode(const SearchNode& arg);

assign methods:

boolean assign(const SearchNode& copy_node);

i/o methods:

long sofSize() const;

boolean read(Sof& sof, long tag, const String& name = 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& name = CLASS_NAME) const;

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

equality methods:

boolean eq(const SearchNode& compare_node) 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 symbol id methods:

boolean setSymbolId(long symbol_id);

long getSymbolId() const;

declare symbol access methods:

boolean setSymbol(const SearchSymbol& symbol);

boolean getSymbol(SearchSymbol& output_symbol) const;

declare statistical model methods:

boolean setStatisticalModel(StatisticalModel* model);

StatisticalModel* getStatisticalModel() const;

declare symbol likelihood methods:

boolean setScore(float score);

float getScore() const;

declare search level methods:

boolean setSearchLevel(SearchLevel* level);

SearchLevel* getSearchLevel() const;

declare lexical tree methods:

boolean setLexicalTree(LexicalTree* lex_tree_a);

LexicalTree* getLexicalTree() const;

declare hypothesis path methods:

boolean addTrace(Trace* trace, long timestamp, Trace*& ptr);

boolean mergeTrace(Trace* trace, long timestamp, Trace*& pt, long nsymbol_index, long nsymbol_orderr);

boolean removeTrace(Trace* trace);

boolean clearTraceList();

boolean addInstance(Instance* instance, long timestamp, Instance*& ptr);

boolean insertInstance(Instance* instance, long timestamp, Instance*& ptr);

boolean mergeInstance(Instance* instance, long timestamp, Instance*& ptr, long nsymbol_index, long nsymbol_order);

boolean removeInstance(Instance* instance);

boolean clearInstanceList();

declare likelihood evaluation methods:

float evaluateData(VectorFloat& data, long timestamp);

boolean isDummyNode() const;

private methods:

trace tracking methods:

boolean addWithViterbi(Trace* trace, Trace*& ptr);

boolean addWithBaumWelch(Trace* trace, Trace*& ptr);

instance tracking methods:

boolean addWithViterbi(Instance* instance, Instance*& ptr);

boolean insertWithViterbi(Instance* instance, Instance*& ptr);

boolean addWithBaumWelch(Instance* instance, Instance*& ptr);

examples:

none.

notes:

none.