name: Trace

synopsis:

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

#include <Trace.h>

~Trace();
Trace();
Trace(const Trace& copy_sym);

boolean setScore(float score);
boolean setHistory(const History& copy_history);
boolean setBackPointer(Trace* back_ptr);
ulong incrementRefCount(ulong increment = DEF_REF_INCR);
boolean setFrame(ulong frame);
boolean setActive(boolean is_active);

quick start:

x
#include <Trace.h>

// seed the top trace list with the start node of the search graph
//
Trace trace = new Trace();
trace.setFrame(0);
trace.setBackPointer((Trace*)NULL);
trace.getHistory()->push(search_levels_d(0).getSubGraph(0).getStart());

description:

Trace is the path marker for the search. Trace essentially defines the path we have taken to the current point in the search and maintains the total path score for a point in the search.

dependencies:

public constants:

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

define the trace mode choices:

enum TMODE { DECODE = 0, TRAIN, DEF_TMODE = DECODE};

other important constants:

static const float INACTIVE_SCORE = -11111111111111.0f;

define the default value(s) of the class data:

static const float DEF_SCORE = 0.0;

static const ulong DEF_FRAME = 0;

define default arguments to methods:

static const ulong DEF_REF_INCR = 1;

static const ulong DEF_REF_DECR = 1;

error codes:

error code indicating a general error:
```
static const long ERR = 90000;
```
error code indicating an i/o error:
```
static const long READ = 90001;
```

protected data:

define a trace mode flag:

TMODE trace_mode_d;

define a structure to maintain previous n-symbols:

Context** nsymbol_d;

define a back pointer to the previous trace(s):

SingleLinkedList<Trace> back_ptr_d;

define a structure to maintain the trace's location in the search space:

History history_d;

define the reference to symbol graph node

SymbolGraphNode* symbol_node_d;

define the score for the path in the search space that this trace represents:

float score_d;

define the lm score for the path in the search space that this trace represents

float lm_score_d;

the time frame that this trace is in:

ulong frame_d;

define a reference count that says when this trace can be deleted:

ulong reference_count_d;

memory manager:
```
static MemoryManager mgr_d;
```
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):

~Trace();

Trace(float score = DEF_SCORE);

Trace(const Trace& arg);

assign methods:

boolean assign(const Trace& copy_trace);

i/o methods:

long sofSize() const;

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

boolean readData(Sof& sof, const String& pname = String::EMPTY, 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 Trace& compare_trace) const;

boolean operator < (const Trace& trace_a);

boolean operator > (const Trace& trace_a);

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:

trace set/get methods:

boolean setTraceMode(TMODE arg);

TMODE getTraceMode();

score manipulation methods:

boolean setScore(float score);

float getScore() const;

boolean setLMScore(float score);

float getLMScore() const;

boolean setNSymbol(Context**& arg);

Context**& getNSymbol();

boolean setSymbolNode(SymbolGraphNode* arg);

SymbolGraphNode* getSymbolNode();

history related methods:

boolean setHistory(const History& copy_history);

History* getHistory() const;

boolean setBackPointer(Trace* back_ptr);

Trace* getBackPointer() const;

ulong decrementRefCount(ulong decrement = DEF_REF_DECR);

ulong incrementRefCount(ulong increment = DEF_REF_INCR);

ulong getRefCount() const;

boolean setRefCount(ulong count);

boolean setFrame(ulong frame);

ulong getFrame() const;

trace activity methods:

boolean setActive(boolean is_active);

boolean isActive() const;

trace deletion methods:

static boolean deleteTrace(Trace* in_trace, boolean is_recursive, boolean clean_search_node = false);

static boolean deleteTrace(Trace* in_trace, boolean is_recursive, BiGraph<TrainNode>* trellis, HashTable<HashKey<Trace>, BiGraphVertex<TrainNode> >* mapping, boolean clean_search_node = false);

static boolean deleteBackTraces(Trace* in_trace, boolean is_recursive, boolean clean_search_node = false);

static boolean deleteBackTraces(Trace* in_trace, boolean is_recursive, BiGraph<TrainNode>* trellis, HashTable<HashKey<Trace>, BiGraphVertex<TrainNode> >* mapping, boolean clean_search_node = false);

long hash(long capacity) const;

private methods:

none

examples:

This example shows how to build a simple search structure and how to generate all paths through it.

notes:

none