PUBLIC

Mesh2dC::Mesh2dC(void) Mesh2dC::Mesh2dC(const Mesh2dC &) Mesh2dC::Mesh2dC(const DListC> &) GraphTC::Copy(void) GraphTC::Copy(HashARC &) GraphTC::operator=(const GraphTC &) GraphTC::InsNode(const NodeT &) GraphTC::InsEdge(NodeIter &,NodeIter &,const EdgeT &) GraphTC::InsEdge(const GraphNodeHC &,const GraphNodeHC &,const EdgeT &) GraphTC::NoNodes(void) const GraphTC::NoEdges(void) const GraphTC::IsCyclic(void) GraphTC::DebugPrint(ostream &) const GraphTC::Copy(HashARC,GraphNodeIterC> &) GraphTC::InsEdge(GraphNodeIterC &,GraphNodeIterC &,const EdgeT &) GraphC::operator=(const GraphC &) GraphC::InsNode(void) GraphC::InsEdge(GraphNodeC &,GraphNodeC &) GraphC::Type(void) const GraphC::operator BaseGraphC &(void) GraphC::operator const BaseGraphC &(void) const GraphC::BaseGraph(void) GraphC::BaseGraph(void) const GraphC::Nodes(void) const GraphC::Nodes(void) GraphC::Edges(void) const GraphC::Edges(void) GraphC::IsCyclic(void) GraphC::ResetNodeMarkers(void) GraphC::ResetEdgeMarkers(void) GraphC::ResetMarkers(void) GraphC::SetNodeMarkersInOrder(void) GraphC::SetEdgeMarkersInOrder(void) GraphC::SetMarkersInOrder(void) GraphC::PrintNodes(ostream &) const GraphC::PrintEdges(ostream &) const GraphC::Print(ostream &) GraphC::DebugPrint(ostream &) const GraphC::InsNode(GraphNodeRepC::GenClassT) GraphC::InsEdge(GraphNodeC &,GraphNodeC &,GraphEdgeRepC::GenClassT) GraphC::InsNode(GraphNodeRepC &) GraphC::InsEdge(GraphEdgeRepC &) GraphC::operator<<(ostream &,const GraphC &) RefCounterC::ToBeDeleted(void) const RefCounterC::Count(void) const RefCounterC::IsSingleReference(void) RefCounterC::operator=(const RefCounterC &) RefCounterC::ToBeDeletedUpdate(const RefCounterC &) RefCounterC::ReportInvalidObject(char *) RefCounterBaseC::Label(void) const

Mesh2dC<class NodeT,class EdgeT>
Class to store a 2D mesh
include	"amma/Mesh2d.hh"
User Level:	Default
Library:	Mesh2d
Example:	exBnd.cc
Section:	Geometry.Mesh2d
In Scope:	std

Comments:
Class to store a 2D mesh. NodeT must be derived from Mesh2dNodeC; EdgeT must be derived from Mesh2dEdgeC

public GraphTC<class NodeT,class EdgeT>

Mesh2dC()

Default constructor.

Mesh2dC(const Mesh2dC & mesh)

Copy constructor.

Mesh2dC(const DListC<PairC<NodeT>> & edges)

Build the mesh from the list of nodes and edges

GraphTC<NodeT,EdgeT> Copy()

Make a copy of this graph.

GraphTC<NodeT,EdgeT> Copy(HashARC<NodeIter,NodeIter> & NodeMap)

Make a copy of this graph.
The mapping between new and old nodes is in NodeMap.

const GraphTC<NodeT,EdgeT> & operator=(const GraphTC<NodeT,EdgeT> & g)

Creates another access to the graph 'g'.
The assigment does not change the content of the graph 'g', but its reference counting. However, the content of the graph 'g' can be changed through the this new access later. Creation of the structure of the graph. ---------------------------------------

GraphNodeIterC<NodeT,EdgeT> InsNode(const NodeT & Dat)

Inserts one node to the graph.
Returns the node iterator pointing to the new element.

GraphEdgeIterC<NodeT,EdgeT> InsEdge(NodeIter & fromNode,NodeIter & toNode,const EdgeT & Dat)

Inserts one egde to the graph.
Returns an edge iterator pointing to the new element.

GraphEdgeIterC<NodeT,EdgeT> InsEdge(const GraphNodeHC<NodeT,EdgeT> & fromNode,const GraphNodeHC<NodeT,EdgeT> & toNode,const EdgeT & Dat)

Inserts one egde to the graph.
Returns an edge iterator pointing to the new element.

UIntT NoNodes() const

Count the number of nodes in the graph.
This actuall iterates through the list and is slow.

UIntT NoEdges() const

Count the number of edges in the graph.
This actuall iterates through the list and is slow. Tests on graph structure. ---------------------------------------

BooleanT IsCyclic()

Test if a directed graph contains cycles.

void DebugPrint(ostream & s) const

Prints markers and addresses of all nodes and edges of this graph.

GraphTC<NodeT,EdgeT> Copy(HashARC<GraphNodeIterC<NodeT,EdgeT>,GraphNodeIterC<NodeT,EdgeT>> & NodeMap)

///////////////////////////// Inserts one node to the graph. Returns the node iterator.

GraphEdgeIterC<NodeT,EdgeT> InsEdge(GraphNodeIterC<NodeT,EdgeT> & fromNode,GraphNodeIterC<NodeT,EdgeT> & toNode,const EdgeT & Dat)

const GraphC & operator=(const GraphC & g)

GraphNodeC InsNode()

Inserts one node to the graph. Returns the node iterator.

GraphEdgeC InsEdge(GraphNodeC & fromNode,GraphNodeC & toNode)

Inserts one egde to the graph. Returns the edge iterator. Access to the parts of the graph --------------------------------

BaseGraphC::TypeT Type() const

Returns the type of the graph, if it is directed or undirected.

operator BaseGraphC &()

Returns the reference to the graph structure which is not reference counted.

operator const BaseGraphC &() const

Returns the constant reference to the graph structure which is not reference counted.

BaseGraphC & BaseGraph()

Returns the reference to the graph structure which is not reference counted.

const BaseGraphC & BaseGraph() const

Returns the reference to the graph structure which is not reference counted.

const IntrDListC<GraphNodeRepC> & Nodes() const

Returns the constant list of nodes.

IntrDListC<GraphNodeRepC> & Nodes()

Returns the list of nodes.

const IntrDListC<GraphEdgeRepC> & Edges() const

Returns the constant list of edges.

IntrDListC<GraphEdgeRepC> & Edges()

Returns the list of edges.

BooleanT IsCyclic()

Test if a directed graph contains cycles. Functions changing the state of markers. ----------------------------------------

void ResetNodeMarkers()

Sets all node markers to be 0.

void ResetEdgeMarkers()

Sets all egde markers to be 0.

void ResetMarkers()

Sets all node and edge markers to be 0.

void SetNodeMarkersInOrder()

Sets all node markers as indexes in the list of nodes. The first node in the list of nodes has index 0.

void SetEdgeMarkersInOrder()

Sets all edge markers as indexes in the list of edges. The first edge in the list of edges has index 0.

void SetMarkersInOrder()

Sets all edge and node markers as indexes in the list of edges and in the list of node respectively. The first edge in the list of edges and the first node in the list of nodes have indexes equal to 0. Saving information about the graph. -----------------------------------

void PrintNodes(ostream & s) const

Prints all nodes of this graph into the output stream.

void PrintEdges(ostream & s) const

Prints all edges of this graph into the output stream.

void Print(ostream & s)

Sets marker of edges and nodes to be unique and print the whole structure of this graph.

void DebugPrint(ostream & s) const

Prints markers and addresses of all nodes and edges of this graph.

GraphNodeC InsNode(GraphNodeRepC::GenClassT nodeAttr)

Inserts one node to the graph. Returns the node iterator.

GraphEdgeC InsEdge(GraphNodeC & fromNode,GraphNodeC & toNode,GraphEdgeRepC::GenClassT edgeAttr)

Inserts one edge to the graph. Returns the edge iterator.

GraphNodeC InsNode(GraphNodeRepC & ANode)

Inserts one node to the graph. Returns the node iterator. ANode must be a GraphNodeRepC that's just been created, and not a part of another graph.

GraphEdgeC InsEdge(GraphEdgeRepC & AnEdge)

Inserts one edge to the graph. Returns the edge iterator. AnEdge must be a GraphEdgeRepC that's just been created, and not a part of another graph.

ostream & operator<<(ostream & s,const GraphC & g)

BooleanT ToBeDeleted() const

Returns TRUE if the content should be deleted.

RCCountT Count() const

Returns the number of refrences to this object. NB. The following definition is now obsolete, The value 0 means there is no other reference to this object.

BooleanT IsSingleReference()

Tests is there is only one reference to this object.

const RefCounterC & operator=(const RefCounterC & rC)

BooleanT ToBeDeletedUpdate(const RefCounterC & rC)

This function is the condition and the assigment together. It returns TRUE if the content should be deleted before assigning of the new object. The function automatically solves the reference counter of this object as well as the other object reference counter 'rC'.

void ReportInvalidObject(char * Msg = 0)

This function reports an error to the user if a problem is detected in the refrence counting mechanism.

LabelT Label() const

Returns the label of this reference counter.
The member function is useful mainly to recognize objects during debugging. The value of the label is uniquely defined pointer.