name: BiGraphArc <TObject>

synopsis:

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

#include ;

BiGraphArc(const BiGraphArc<TObject>& copy_arc);
boolean setVertex(BiGraphVertex<TObject>* dest);
BiGraphVertex<TObject>* getVertex() const;
boolean containsData() const;

quick start:

// declare the graph arc object
//
BiGraphArc<Char> arc;
BiGraphVertex<Char> vertex;

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

description:

BiGraphArc 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"BiGraphArc";

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

default arguments to methods:

static const float DEF_WEIGHT = 0.0;

static const boolean DEF_EPSILON = false;

error codes:

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

protected data:

vertex we are pointing to:

BiGraphVertex<TObject>* vertex_d;

weight for the edge:

Float weight_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 BiGraph classes.
```
static const String& name();
```

debug methods:

static boolean setDebug(Integral::DEBUG level);

boolean debug(const unichar* message) const;

destructor/constructor(s):

~BiGraphArc();

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

BiGraphArc(const BiGraphArc<TObject>& copy_arc);

assign methods:

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

operator= methods:

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

equality methods:

boolean eq(const BiGraphArc<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(BiGraphArcVertex<TObject>* dest);

BiGraphVertex<TObject>* getVertex() const;

arc weight get and set methods:

boolean setWeight(float weight);

float getWeight() const;

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 BiGraphArc:

// create some temporary objects and items
//  
BiGraphVertex vert0;
BiGraphVertex vert1;
  
BiGraphArc tmp_arc;
BiGraphArc* tmp_dyn_arc = new BiGraphArc();
  
// 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 BiGraphArc class is a support class for the BiGraph class.