name: GraphArc <TObject>

synopsis:

g++ [flags ...] file ...

#include ;

GraphArc(const GraphArc<TObject>& copy_arc);
boolean setVertex(GraphVertex<TObject>* dest);
GraphVertex<TObject>* getVertex() const;
boolean containsData() const;

quick start:

// declare the graph arc object
//
GraphArc<Char> arc;
GraphVertex<Char> vertex;

// set the items
//
arc.setVertex(&vertex);
arc.setWeight(0.9);
arc.setEpsilon(true);

description:

GraphArc is a generic arc in a graph. The main purpose of an arc is to connect two graph vertices. This class also provides support to the Graph class.

dependencies:

public constants:

define the class name:

static const String CLASS_NAME = L"GraphArc";

i/o related constants:
```
static const String DEF_PARAM = L"arc";
```

default arguments to methods:

static const float DEF_WEIGHT = 0.0;

static const double DEF_OPTIONAL_WEIGHT = 0.0;

static const boolean DEF_EPSILON = false;

error codes:

error code indicating GraphArc class general error:
```
static const long ERR = 41000;
```

protected data:

vertex we are pointing to:

GraphVertex<TObject>* vertex_d;

weight for the edge:

Float weight_d;

alternative weight 1:

Double weight1_d;

alternative weight 2:

Double weight2_d;

is this an epsilon transition:

Boolean is_epsilon_d;

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

required public methods:

static methods: this class currently does not have a standalone diagnose method. Instead, it is tested extensively in the DiGraph classes.
```
static const String& name();
```

debug methods:

static boolean setDebug(Integral::DEBUG level);

boolean debug(const unichar* message) const;

destructor/constructor(s):

~GraphArc();

GraphArc(GraphVertex<TObject>* = (GraphVertex<TObject>*)NULL, float weight = DEF_WEIGHT, boolean is_epsilon = DEF_EPSILON);

GraphArc(const GraphArc<TObject>& copy_arc);

assign methods:

boolean assign(const GraphArc<TObject>& copy_arc);

operator= methods:

GraphArc<TObject>& operator=(const GraphArc<TObject>& arg);

equality methods:

boolean eq(const GraphArc<TObject>& compare_arc) const;

i/o methods:

i/o methods are not defined for this class.

memory management methods:

void* operator new(size_t size);

void* operator new[](size_t size);

void operator delete(void* ptr);

void operator delete[](void* ptr);

static boolean setGrowSize(long grow_size);

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

class-specific public methods:

endpoint vertex get and set methods:

boolean setVertex(GraphArcVertex<TObject>* dest);

GraphVertex<TObject>* getVertex() const;

arc weight get and set methods:

boolean setWeight(const float weight);

float getWeight() const;

accumulator get and set methods:

boolean setAccumulator(const double weight);

double getAccumulator();

language weight get and set methods:

boolean setLanguageWeight(const double weight);

double getLanguageWeight();

acoustic weight get and set methods:

boolean setAcousticWeight(const double weight);

double getAcousticWeight();

arc epsilon flag get and set methods:

boolean setEpsilon(boolean is_epsilon = DEF_EPSILON);

boolean getEpsilon() const;

method to check if the arc has any information that need to be written:
```
boolean containsData() const;
```

private methods:

none.

examples:

This example shows how to assign a GraphArc:

// create some temporary objects and items
//  
GraphVertex vert0;
GraphVertex vert1;
  
GraphArc tmp_arc;
GraphArc* tmp_dyn_arc = new GraphArc();
  
// set the items
//
tmp_dyn_arc->setVertex(&vert1);
tmp_dyn_arc->setWeight(0.79);
tmp_dyn_arc->setEpsilon(true);

// try the copy assign
//
tmp_arc.assign(*tmp_dyn_arc);
  
if ((tmp_arc.vertex_d != &vert1) ||
    (tmp_dyn_arc->vertex_d != &vert1) ||
    !(tmp_arc.weight_d.almostEqual(0.79)) ||
    !(tmp_dyn_arc->weight_d.almostEqual(0.79)) ||
    !tmp_arc.is_epsilon_d ||
    !tmp_dyn_arc->is_epsilon_d) {
  Console::put(L"Error in assign method");  
}

notes:

The GraphArc class is a support class for the DiGraph class.