1421 lines
37 KiB
C++
Executable File
1421 lines
37 KiB
C++
Executable File
/* -*- mode: C++; indent-tabs-mode: nil; -*-
|
|
*
|
|
* This file is a part of LEMON, a generic C++ optimization library.
|
|
*
|
|
* Copyright (C) 2003-2013
|
|
* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
|
|
* (Egervary Research Group on Combinatorial Optimization, EGRES).
|
|
*
|
|
* Permission to use, modify and distribute this software is granted
|
|
* provided that this copyright notice appears in all copies. For
|
|
* precise terms see the accompanying LICENSE file.
|
|
*
|
|
* This software is provided "AS IS" with no warranty of any kind,
|
|
* express or implied, and with no claim as to its suitability for any
|
|
* purpose.
|
|
*
|
|
*/
|
|
|
|
#ifndef LEMON_EDGE_SET_H
|
|
#define LEMON_EDGE_SET_H
|
|
|
|
#include <lemon/core.h>
|
|
#include <lemon/bits/edge_set_extender.h>
|
|
|
|
/// \ingroup graphs
|
|
/// \file
|
|
/// \brief ArcSet and EdgeSet classes.
|
|
///
|
|
/// Graphs which use another graph's node-set as own.
|
|
namespace lemon {
|
|
|
|
template <typename GR>
|
|
class ListArcSetBase {
|
|
public:
|
|
|
|
typedef typename GR::Node Node;
|
|
typedef typename GR::NodeIt NodeIt;
|
|
|
|
protected:
|
|
|
|
struct NodeT {
|
|
int first_out, first_in;
|
|
NodeT() : first_out(-1), first_in(-1) {}
|
|
};
|
|
|
|
typedef typename ItemSetTraits<GR, Node>::
|
|
template Map<NodeT>::Type NodesImplBase;
|
|
|
|
NodesImplBase* _nodes;
|
|
|
|
struct ArcT {
|
|
Node source, target;
|
|
int next_out, next_in;
|
|
int prev_out, prev_in;
|
|
ArcT() : prev_out(-1), prev_in(-1) {}
|
|
};
|
|
|
|
std::vector<ArcT> arcs;
|
|
|
|
int first_arc;
|
|
int first_free_arc;
|
|
|
|
const GR* _graph;
|
|
|
|
void initalize(const GR& graph, NodesImplBase& nodes) {
|
|
_graph = &graph;
|
|
_nodes = &nodes;
|
|
}
|
|
|
|
public:
|
|
|
|
class Arc {
|
|
friend class ListArcSetBase<GR>;
|
|
protected:
|
|
Arc(int _id) : id(_id) {}
|
|
int id;
|
|
public:
|
|
Arc() {}
|
|
Arc(Invalid) : id(-1) {}
|
|
bool operator==(const Arc& arc) const { return id == arc.id; }
|
|
bool operator!=(const Arc& arc) const { return id != arc.id; }
|
|
bool operator<(const Arc& arc) const { return id < arc.id; }
|
|
};
|
|
|
|
ListArcSetBase() : first_arc(-1), first_free_arc(-1) {}
|
|
|
|
Node addNode() {
|
|
LEMON_ASSERT(false,
|
|
"This graph structure does not support node insertion");
|
|
return INVALID; // avoid warning
|
|
}
|
|
|
|
Arc addArc(const Node& u, const Node& v) {
|
|
int n;
|
|
if (first_free_arc == -1) {
|
|
n = arcs.size();
|
|
arcs.push_back(ArcT());
|
|
} else {
|
|
n = first_free_arc;
|
|
first_free_arc = arcs[first_free_arc].next_in;
|
|
}
|
|
arcs[n].next_in = (*_nodes)[v].first_in;
|
|
if ((*_nodes)[v].first_in != -1) {
|
|
arcs[(*_nodes)[v].first_in].prev_in = n;
|
|
}
|
|
(*_nodes)[v].first_in = n;
|
|
arcs[n].next_out = (*_nodes)[u].first_out;
|
|
if ((*_nodes)[u].first_out != -1) {
|
|
arcs[(*_nodes)[u].first_out].prev_out = n;
|
|
}
|
|
(*_nodes)[u].first_out = n;
|
|
arcs[n].source = u;
|
|
arcs[n].target = v;
|
|
return Arc(n);
|
|
}
|
|
|
|
void erase(const Arc& arc) {
|
|
int n = arc.id;
|
|
if (arcs[n].prev_in != -1) {
|
|
arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
|
|
} else {
|
|
(*_nodes)[arcs[n].target].first_in = arcs[n].next_in;
|
|
}
|
|
if (arcs[n].next_in != -1) {
|
|
arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
|
|
}
|
|
|
|
if (arcs[n].prev_out != -1) {
|
|
arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
|
|
} else {
|
|
(*_nodes)[arcs[n].source].first_out = arcs[n].next_out;
|
|
}
|
|
if (arcs[n].next_out != -1) {
|
|
arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
|
|
}
|
|
|
|
}
|
|
|
|
void clear() {
|
|
Node node;
|
|
for (first(node); node != INVALID; next(node)) {
|
|
(*_nodes)[node].first_in = -1;
|
|
(*_nodes)[node].first_out = -1;
|
|
}
|
|
arcs.clear();
|
|
first_arc = -1;
|
|
first_free_arc = -1;
|
|
}
|
|
|
|
void first(Node& node) const {
|
|
_graph->first(node);
|
|
}
|
|
|
|
void next(Node& node) const {
|
|
_graph->next(node);
|
|
}
|
|
|
|
void first(Arc& arc) const {
|
|
Node node;
|
|
first(node);
|
|
while (node != INVALID && (*_nodes)[node].first_in == -1) {
|
|
next(node);
|
|
}
|
|
arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
|
|
}
|
|
|
|
void next(Arc& arc) const {
|
|
if (arcs[arc.id].next_in != -1) {
|
|
arc.id = arcs[arc.id].next_in;
|
|
} else {
|
|
Node node = arcs[arc.id].target;
|
|
next(node);
|
|
while (node != INVALID && (*_nodes)[node].first_in == -1) {
|
|
next(node);
|
|
}
|
|
arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_in;
|
|
}
|
|
}
|
|
|
|
void firstOut(Arc& arc, const Node& node) const {
|
|
arc.id = (*_nodes)[node].first_out;
|
|
}
|
|
|
|
void nextOut(Arc& arc) const {
|
|
arc.id = arcs[arc.id].next_out;
|
|
}
|
|
|
|
void firstIn(Arc& arc, const Node& node) const {
|
|
arc.id = (*_nodes)[node].first_in;
|
|
}
|
|
|
|
void nextIn(Arc& arc) const {
|
|
arc.id = arcs[arc.id].next_in;
|
|
}
|
|
|
|
int id(const Node& node) const { return _graph->id(node); }
|
|
int id(const Arc& arc) const { return arc.id; }
|
|
|
|
Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
|
|
Arc arcFromId(int ix) const { return Arc(ix); }
|
|
|
|
int maxNodeId() const { return _graph->maxNodeId(); };
|
|
int maxArcId() const { return arcs.size() - 1; }
|
|
|
|
Node source(const Arc& arc) const { return arcs[arc.id].source;}
|
|
Node target(const Arc& arc) const { return arcs[arc.id].target;}
|
|
|
|
typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
|
|
|
|
NodeNotifier& notifier(Node) const {
|
|
return _graph->notifier(Node());
|
|
}
|
|
|
|
template <typename V>
|
|
class NodeMap : public GR::template NodeMap<V> {
|
|
typedef typename GR::template NodeMap<V> Parent;
|
|
|
|
public:
|
|
|
|
explicit NodeMap(const ListArcSetBase<GR>& arcset)
|
|
: Parent(*arcset._graph) {}
|
|
|
|
NodeMap(const ListArcSetBase<GR>& arcset, const V& value)
|
|
: Parent(*arcset._graph, value) {}
|
|
|
|
NodeMap& operator=(const NodeMap& cmap) {
|
|
return operator=<NodeMap>(cmap);
|
|
}
|
|
|
|
template <typename CMap>
|
|
NodeMap& operator=(const CMap& cmap) {
|
|
Parent::operator=(cmap);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
};
|
|
|
|
/// \ingroup graphs
|
|
///
|
|
/// \brief Digraph using a node set of another digraph or graph and
|
|
/// an own arc set.
|
|
///
|
|
/// This structure can be used to establish another directed graph
|
|
/// over a node set of an existing one. This class uses the same
|
|
/// Node type as the underlying graph, and each valid node of the
|
|
/// original graph is valid in this arc set, therefore the node
|
|
/// objects of the original graph can be used directly with this
|
|
/// class. The node handling functions (id handling, observing, and
|
|
/// iterators) works equivalently as in the original graph.
|
|
///
|
|
/// This implementation is based on doubly-linked lists, from each
|
|
/// node the outgoing and the incoming arcs make up lists, therefore
|
|
/// one arc can be erased in constant time. It also makes possible,
|
|
/// that node can be removed from the underlying graph, in this case
|
|
/// all arcs incident to the given node is erased from the arc set.
|
|
///
|
|
/// This class fully conforms to the \ref concepts::Digraph
|
|
/// "Digraph" concept.
|
|
/// It provides only linear time counting for nodes and arcs.
|
|
///
|
|
/// \param GR The type of the graph which shares its node set with
|
|
/// this class. Its interface must conform to the
|
|
/// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
|
|
/// concept.
|
|
template <typename GR>
|
|
class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
|
|
typedef ArcSetExtender<ListArcSetBase<GR> > Parent;
|
|
|
|
public:
|
|
|
|
typedef typename Parent::Node Node;
|
|
typedef typename Parent::Arc Arc;
|
|
|
|
typedef typename Parent::NodesImplBase NodesImplBase;
|
|
|
|
void eraseNode(const Node& node) {
|
|
Arc arc;
|
|
Parent::firstOut(arc, node);
|
|
while (arc != INVALID ) {
|
|
erase(arc);
|
|
Parent::firstOut(arc, node);
|
|
}
|
|
|
|
Parent::firstIn(arc, node);
|
|
while (arc != INVALID ) {
|
|
erase(arc);
|
|
Parent::firstIn(arc, node);
|
|
}
|
|
}
|
|
|
|
void clearNodes() {
|
|
Parent::clear();
|
|
}
|
|
|
|
class NodesImpl : public NodesImplBase {
|
|
typedef NodesImplBase Parent;
|
|
|
|
public:
|
|
NodesImpl(const GR& graph, ListArcSet& arcset)
|
|
: Parent(graph), _arcset(arcset) {}
|
|
|
|
virtual ~NodesImpl() {}
|
|
|
|
protected:
|
|
|
|
virtual void erase(const Node& node) {
|
|
_arcset.eraseNode(node);
|
|
Parent::erase(node);
|
|
}
|
|
virtual void erase(const std::vector<Node>& nodes) {
|
|
for (int i = 0; i < int(nodes.size()); ++i) {
|
|
_arcset.eraseNode(nodes[i]);
|
|
}
|
|
Parent::erase(nodes);
|
|
}
|
|
virtual void clear() {
|
|
_arcset.clearNodes();
|
|
Parent::clear();
|
|
}
|
|
|
|
private:
|
|
ListArcSet& _arcset;
|
|
};
|
|
|
|
NodesImpl _nodes;
|
|
|
|
public:
|
|
|
|
/// \brief Constructor of the ArcSet.
|
|
///
|
|
/// Constructor of the ArcSet.
|
|
ListArcSet(const GR& graph) : _nodes(graph, *this) {
|
|
Parent::initalize(graph, _nodes);
|
|
}
|
|
|
|
/// \brief Add a new arc to the digraph.
|
|
///
|
|
/// Add a new arc to the digraph with source node \c s
|
|
/// and target node \c t.
|
|
/// \return The new arc.
|
|
Arc addArc(const Node& s, const Node& t) {
|
|
return Parent::addArc(s, t);
|
|
}
|
|
|
|
/// \brief Erase an arc from the digraph.
|
|
///
|
|
/// Erase an arc \c a from the digraph.
|
|
void erase(const Arc& a) {
|
|
return Parent::erase(a);
|
|
}
|
|
|
|
};
|
|
|
|
template <typename GR>
|
|
class ListEdgeSetBase {
|
|
public:
|
|
|
|
typedef typename GR::Node Node;
|
|
typedef typename GR::NodeIt NodeIt;
|
|
|
|
protected:
|
|
|
|
struct NodeT {
|
|
int first_out;
|
|
NodeT() : first_out(-1) {}
|
|
};
|
|
|
|
typedef typename ItemSetTraits<GR, Node>::
|
|
template Map<NodeT>::Type NodesImplBase;
|
|
|
|
NodesImplBase* _nodes;
|
|
|
|
struct ArcT {
|
|
Node target;
|
|
int prev_out, next_out;
|
|
ArcT() : prev_out(-1), next_out(-1) {}
|
|
};
|
|
|
|
std::vector<ArcT> arcs;
|
|
|
|
int first_arc;
|
|
int first_free_arc;
|
|
|
|
const GR* _graph;
|
|
|
|
void initalize(const GR& graph, NodesImplBase& nodes) {
|
|
_graph = &graph;
|
|
_nodes = &nodes;
|
|
}
|
|
|
|
public:
|
|
|
|
class Edge {
|
|
friend class ListEdgeSetBase;
|
|
protected:
|
|
|
|
int id;
|
|
explicit Edge(int _id) { id = _id;}
|
|
|
|
public:
|
|
Edge() {}
|
|
Edge (Invalid) { id = -1; }
|
|
bool operator==(const Edge& arc) const {return id == arc.id;}
|
|
bool operator!=(const Edge& arc) const {return id != arc.id;}
|
|
bool operator<(const Edge& arc) const {return id < arc.id;}
|
|
};
|
|
|
|
class Arc {
|
|
friend class ListEdgeSetBase;
|
|
protected:
|
|
Arc(int _id) : id(_id) {}
|
|
int id;
|
|
public:
|
|
operator Edge() const { return edgeFromId(id / 2); }
|
|
|
|
Arc() {}
|
|
Arc(Invalid) : id(-1) {}
|
|
bool operator==(const Arc& arc) const { return id == arc.id; }
|
|
bool operator!=(const Arc& arc) const { return id != arc.id; }
|
|
bool operator<(const Arc& arc) const { return id < arc.id; }
|
|
};
|
|
|
|
ListEdgeSetBase() : first_arc(-1), first_free_arc(-1) {}
|
|
|
|
Node addNode() {
|
|
LEMON_ASSERT(false,
|
|
"This graph structure does not support node insertion");
|
|
return INVALID; // avoid warning
|
|
}
|
|
|
|
Edge addEdge(const Node& u, const Node& v) {
|
|
int n;
|
|
|
|
if (first_free_arc == -1) {
|
|
n = arcs.size();
|
|
arcs.push_back(ArcT());
|
|
arcs.push_back(ArcT());
|
|
} else {
|
|
n = first_free_arc;
|
|
first_free_arc = arcs[n].next_out;
|
|
}
|
|
|
|
arcs[n].target = u;
|
|
arcs[n | 1].target = v;
|
|
|
|
arcs[n].next_out = (*_nodes)[v].first_out;
|
|
if ((*_nodes)[v].first_out != -1) {
|
|
arcs[(*_nodes)[v].first_out].prev_out = n;
|
|
}
|
|
(*_nodes)[v].first_out = n;
|
|
arcs[n].prev_out = -1;
|
|
|
|
if ((*_nodes)[u].first_out != -1) {
|
|
arcs[(*_nodes)[u].first_out].prev_out = (n | 1);
|
|
}
|
|
arcs[n | 1].next_out = (*_nodes)[u].first_out;
|
|
(*_nodes)[u].first_out = (n | 1);
|
|
arcs[n | 1].prev_out = -1;
|
|
|
|
return Edge(n / 2);
|
|
}
|
|
|
|
void erase(const Edge& arc) {
|
|
int n = arc.id * 2;
|
|
|
|
if (arcs[n].next_out != -1) {
|
|
arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
|
|
}
|
|
|
|
if (arcs[n].prev_out != -1) {
|
|
arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
|
|
} else {
|
|
(*_nodes)[arcs[n | 1].target].first_out = arcs[n].next_out;
|
|
}
|
|
|
|
if (arcs[n | 1].next_out != -1) {
|
|
arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
|
|
}
|
|
|
|
if (arcs[n | 1].prev_out != -1) {
|
|
arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
|
|
} else {
|
|
(*_nodes)[arcs[n].target].first_out = arcs[n | 1].next_out;
|
|
}
|
|
|
|
arcs[n].next_out = first_free_arc;
|
|
first_free_arc = n;
|
|
|
|
}
|
|
|
|
void clear() {
|
|
Node node;
|
|
for (first(node); node != INVALID; next(node)) {
|
|
(*_nodes)[node].first_out = -1;
|
|
}
|
|
arcs.clear();
|
|
first_arc = -1;
|
|
first_free_arc = -1;
|
|
}
|
|
|
|
void first(Node& node) const {
|
|
_graph->first(node);
|
|
}
|
|
|
|
void next(Node& node) const {
|
|
_graph->next(node);
|
|
}
|
|
|
|
void first(Arc& arc) const {
|
|
Node node;
|
|
first(node);
|
|
while (node != INVALID && (*_nodes)[node].first_out == -1) {
|
|
next(node);
|
|
}
|
|
arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
|
|
}
|
|
|
|
void next(Arc& arc) const {
|
|
if (arcs[arc.id].next_out != -1) {
|
|
arc.id = arcs[arc.id].next_out;
|
|
} else {
|
|
Node node = arcs[arc.id ^ 1].target;
|
|
next(node);
|
|
while(node != INVALID && (*_nodes)[node].first_out == -1) {
|
|
next(node);
|
|
}
|
|
arc.id = (node == INVALID) ? -1 : (*_nodes)[node].first_out;
|
|
}
|
|
}
|
|
|
|
void first(Edge& edge) const {
|
|
Node node;
|
|
first(node);
|
|
while (node != INVALID) {
|
|
edge.id = (*_nodes)[node].first_out;
|
|
while ((edge.id & 1) != 1) {
|
|
edge.id = arcs[edge.id].next_out;
|
|
}
|
|
if (edge.id != -1) {
|
|
edge.id /= 2;
|
|
return;
|
|
}
|
|
next(node);
|
|
}
|
|
edge.id = -1;
|
|
}
|
|
|
|
void next(Edge& edge) const {
|
|
Node node = arcs[edge.id * 2].target;
|
|
edge.id = arcs[(edge.id * 2) | 1].next_out;
|
|
while ((edge.id & 1) != 1) {
|
|
edge.id = arcs[edge.id].next_out;
|
|
}
|
|
if (edge.id != -1) {
|
|
edge.id /= 2;
|
|
return;
|
|
}
|
|
next(node);
|
|
while (node != INVALID) {
|
|
edge.id = (*_nodes)[node].first_out;
|
|
while ((edge.id & 1) != 1) {
|
|
edge.id = arcs[edge.id].next_out;
|
|
}
|
|
if (edge.id != -1) {
|
|
edge.id /= 2;
|
|
return;
|
|
}
|
|
next(node);
|
|
}
|
|
edge.id = -1;
|
|
}
|
|
|
|
void firstOut(Arc& arc, const Node& node) const {
|
|
arc.id = (*_nodes)[node].first_out;
|
|
}
|
|
|
|
void nextOut(Arc& arc) const {
|
|
arc.id = arcs[arc.id].next_out;
|
|
}
|
|
|
|
void firstIn(Arc& arc, const Node& node) const {
|
|
arc.id = (((*_nodes)[node].first_out) ^ 1);
|
|
if (arc.id == -2) arc.id = -1;
|
|
}
|
|
|
|
void nextIn(Arc& arc) const {
|
|
arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
|
|
if (arc.id == -2) arc.id = -1;
|
|
}
|
|
|
|
void firstInc(Edge &arc, bool& dir, const Node& node) const {
|
|
int de = (*_nodes)[node].first_out;
|
|
if (de != -1 ) {
|
|
arc.id = de / 2;
|
|
dir = ((de & 1) == 1);
|
|
} else {
|
|
arc.id = -1;
|
|
dir = true;
|
|
}
|
|
}
|
|
void nextInc(Edge &arc, bool& dir) const {
|
|
int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);
|
|
if (de != -1 ) {
|
|
arc.id = de / 2;
|
|
dir = ((de & 1) == 1);
|
|
} else {
|
|
arc.id = -1;
|
|
dir = true;
|
|
}
|
|
}
|
|
|
|
static bool direction(Arc arc) {
|
|
return (arc.id & 1) == 1;
|
|
}
|
|
|
|
static Arc direct(Edge edge, bool dir) {
|
|
return Arc(edge.id * 2 + (dir ? 1 : 0));
|
|
}
|
|
|
|
int id(const Node& node) const { return _graph->id(node); }
|
|
static int id(Arc e) { return e.id; }
|
|
static int id(Edge e) { return e.id; }
|
|
|
|
Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
|
|
static Arc arcFromId(int id) { return Arc(id);}
|
|
static Edge edgeFromId(int id) { return Edge(id);}
|
|
|
|
int maxNodeId() const { return _graph->maxNodeId(); };
|
|
int maxEdgeId() const { return arcs.size() / 2 - 1; }
|
|
int maxArcId() const { return arcs.size()-1; }
|
|
|
|
Node source(Arc e) const { return arcs[e.id ^ 1].target; }
|
|
Node target(Arc e) const { return arcs[e.id].target; }
|
|
|
|
Node u(Edge e) const { return arcs[2 * e.id].target; }
|
|
Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
|
|
|
|
typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
|
|
|
|
NodeNotifier& notifier(Node) const {
|
|
return _graph->notifier(Node());
|
|
}
|
|
|
|
template <typename V>
|
|
class NodeMap : public GR::template NodeMap<V> {
|
|
typedef typename GR::template NodeMap<V> Parent;
|
|
|
|
public:
|
|
|
|
explicit NodeMap(const ListEdgeSetBase<GR>& arcset)
|
|
: Parent(*arcset._graph) {}
|
|
|
|
NodeMap(const ListEdgeSetBase<GR>& arcset, const V& value)
|
|
: Parent(*arcset._graph, value) {}
|
|
|
|
NodeMap& operator=(const NodeMap& cmap) {
|
|
return operator=<NodeMap>(cmap);
|
|
}
|
|
|
|
template <typename CMap>
|
|
NodeMap& operator=(const CMap& cmap) {
|
|
Parent::operator=(cmap);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
};
|
|
|
|
/// \ingroup graphs
|
|
///
|
|
/// \brief Graph using a node set of another digraph or graph and an
|
|
/// own edge set.
|
|
///
|
|
/// This structure can be used to establish another graph over a
|
|
/// node set of an existing one. This class uses the same Node type
|
|
/// as the underlying graph, and each valid node of the original
|
|
/// graph is valid in this arc set, therefore the node objects of
|
|
/// the original graph can be used directly with this class. The
|
|
/// node handling functions (id handling, observing, and iterators)
|
|
/// works equivalently as in the original graph.
|
|
///
|
|
/// This implementation is based on doubly-linked lists, from each
|
|
/// node the incident edges make up lists, therefore one edge can be
|
|
/// erased in constant time. It also makes possible, that node can
|
|
/// be removed from the underlying graph, in this case all edges
|
|
/// incident to the given node is erased from the arc set.
|
|
///
|
|
/// This class fully conforms to the \ref concepts::Graph "Graph"
|
|
/// concept.
|
|
/// It provides only linear time counting for nodes, edges and arcs.
|
|
///
|
|
/// \param GR The type of the graph which shares its node set
|
|
/// with this class. Its interface must conform to the
|
|
/// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
|
|
/// concept.
|
|
template <typename GR>
|
|
class ListEdgeSet : public EdgeSetExtender<ListEdgeSetBase<GR> > {
|
|
typedef EdgeSetExtender<ListEdgeSetBase<GR> > Parent;
|
|
|
|
public:
|
|
|
|
typedef typename Parent::Node Node;
|
|
typedef typename Parent::Arc Arc;
|
|
typedef typename Parent::Edge Edge;
|
|
|
|
typedef typename Parent::NodesImplBase NodesImplBase;
|
|
|
|
void eraseNode(const Node& node) {
|
|
Arc arc;
|
|
Parent::firstOut(arc, node);
|
|
while (arc != INVALID ) {
|
|
erase(arc);
|
|
Parent::firstOut(arc, node);
|
|
}
|
|
|
|
}
|
|
|
|
void clearNodes() {
|
|
Parent::clear();
|
|
}
|
|
|
|
class NodesImpl : public NodesImplBase {
|
|
typedef NodesImplBase Parent;
|
|
|
|
public:
|
|
NodesImpl(const GR& graph, ListEdgeSet& arcset)
|
|
: Parent(graph), _arcset(arcset) {}
|
|
|
|
virtual ~NodesImpl() {}
|
|
|
|
protected:
|
|
|
|
virtual void erase(const Node& node) {
|
|
_arcset.eraseNode(node);
|
|
Parent::erase(node);
|
|
}
|
|
virtual void erase(const std::vector<Node>& nodes) {
|
|
for (int i = 0; i < int(nodes.size()); ++i) {
|
|
_arcset.eraseNode(nodes[i]);
|
|
}
|
|
Parent::erase(nodes);
|
|
}
|
|
virtual void clear() {
|
|
_arcset.clearNodes();
|
|
Parent::clear();
|
|
}
|
|
|
|
private:
|
|
ListEdgeSet& _arcset;
|
|
};
|
|
|
|
NodesImpl _nodes;
|
|
|
|
public:
|
|
|
|
/// \brief Constructor of the EdgeSet.
|
|
///
|
|
/// Constructor of the EdgeSet.
|
|
ListEdgeSet(const GR& graph) : _nodes(graph, *this) {
|
|
Parent::initalize(graph, _nodes);
|
|
}
|
|
|
|
/// \brief Add a new edge to the graph.
|
|
///
|
|
/// Add a new edge to the graph with node \c u
|
|
/// and node \c v endpoints.
|
|
/// \return The new edge.
|
|
Edge addEdge(const Node& u, const Node& v) {
|
|
return Parent::addEdge(u, v);
|
|
}
|
|
|
|
/// \brief Erase an edge from the graph.
|
|
///
|
|
/// Erase the edge \c e from the graph.
|
|
void erase(const Edge& e) {
|
|
return Parent::erase(e);
|
|
}
|
|
|
|
};
|
|
|
|
template <typename GR>
|
|
class SmartArcSetBase {
|
|
public:
|
|
|
|
typedef typename GR::Node Node;
|
|
typedef typename GR::NodeIt NodeIt;
|
|
|
|
protected:
|
|
|
|
struct NodeT {
|
|
int first_out, first_in;
|
|
NodeT() : first_out(-1), first_in(-1) {}
|
|
};
|
|
|
|
typedef typename ItemSetTraits<GR, Node>::
|
|
template Map<NodeT>::Type NodesImplBase;
|
|
|
|
NodesImplBase* _nodes;
|
|
|
|
struct ArcT {
|
|
Node source, target;
|
|
int next_out, next_in;
|
|
ArcT() {}
|
|
};
|
|
|
|
std::vector<ArcT> arcs;
|
|
|
|
const GR* _graph;
|
|
|
|
void initalize(const GR& graph, NodesImplBase& nodes) {
|
|
_graph = &graph;
|
|
_nodes = &nodes;
|
|
}
|
|
|
|
public:
|
|
|
|
class Arc {
|
|
friend class SmartArcSetBase<GR>;
|
|
protected:
|
|
Arc(int _id) : id(_id) {}
|
|
int id;
|
|
public:
|
|
Arc() {}
|
|
Arc(Invalid) : id(-1) {}
|
|
bool operator==(const Arc& arc) const { return id == arc.id; }
|
|
bool operator!=(const Arc& arc) const { return id != arc.id; }
|
|
bool operator<(const Arc& arc) const { return id < arc.id; }
|
|
};
|
|
|
|
SmartArcSetBase() {}
|
|
|
|
Node addNode() {
|
|
LEMON_ASSERT(false,
|
|
"This graph structure does not support node insertion");
|
|
return INVALID; // avoid warning
|
|
}
|
|
|
|
Arc addArc(const Node& u, const Node& v) {
|
|
int n = arcs.size();
|
|
arcs.push_back(ArcT());
|
|
arcs[n].next_in = (*_nodes)[v].first_in;
|
|
(*_nodes)[v].first_in = n;
|
|
arcs[n].next_out = (*_nodes)[u].first_out;
|
|
(*_nodes)[u].first_out = n;
|
|
arcs[n].source = u;
|
|
arcs[n].target = v;
|
|
return Arc(n);
|
|
}
|
|
|
|
void clear() {
|
|
Node node;
|
|
for (first(node); node != INVALID; next(node)) {
|
|
(*_nodes)[node].first_in = -1;
|
|
(*_nodes)[node].first_out = -1;
|
|
}
|
|
arcs.clear();
|
|
}
|
|
|
|
void first(Node& node) const {
|
|
_graph->first(node);
|
|
}
|
|
|
|
void next(Node& node) const {
|
|
_graph->next(node);
|
|
}
|
|
|
|
void first(Arc& arc) const {
|
|
arc.id = arcs.size() - 1;
|
|
}
|
|
|
|
static void next(Arc& arc) {
|
|
--arc.id;
|
|
}
|
|
|
|
void firstOut(Arc& arc, const Node& node) const {
|
|
arc.id = (*_nodes)[node].first_out;
|
|
}
|
|
|
|
void nextOut(Arc& arc) const {
|
|
arc.id = arcs[arc.id].next_out;
|
|
}
|
|
|
|
void firstIn(Arc& arc, const Node& node) const {
|
|
arc.id = (*_nodes)[node].first_in;
|
|
}
|
|
|
|
void nextIn(Arc& arc) const {
|
|
arc.id = arcs[arc.id].next_in;
|
|
}
|
|
|
|
int id(const Node& node) const { return _graph->id(node); }
|
|
int id(const Arc& arc) const { return arc.id; }
|
|
|
|
Node nodeFromId(int ix) const { return _graph->nodeFromId(ix); }
|
|
Arc arcFromId(int ix) const { return Arc(ix); }
|
|
|
|
int maxNodeId() const { return _graph->maxNodeId(); };
|
|
int maxArcId() const { return arcs.size() - 1; }
|
|
|
|
Node source(const Arc& arc) const { return arcs[arc.id].source;}
|
|
Node target(const Arc& arc) const { return arcs[arc.id].target;}
|
|
|
|
typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
|
|
|
|
NodeNotifier& notifier(Node) const {
|
|
return _graph->notifier(Node());
|
|
}
|
|
|
|
template <typename V>
|
|
class NodeMap : public GR::template NodeMap<V> {
|
|
typedef typename GR::template NodeMap<V> Parent;
|
|
|
|
public:
|
|
|
|
explicit NodeMap(const SmartArcSetBase<GR>& arcset)
|
|
: Parent(*arcset._graph) { }
|
|
|
|
NodeMap(const SmartArcSetBase<GR>& arcset, const V& value)
|
|
: Parent(*arcset._graph, value) { }
|
|
|
|
NodeMap& operator=(const NodeMap& cmap) {
|
|
return operator=<NodeMap>(cmap);
|
|
}
|
|
|
|
template <typename CMap>
|
|
NodeMap& operator=(const CMap& cmap) {
|
|
Parent::operator=(cmap);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
};
|
|
|
|
|
|
/// \ingroup graphs
|
|
///
|
|
/// \brief Digraph using a node set of another digraph or graph and
|
|
/// an own arc set.
|
|
///
|
|
/// This structure can be used to establish another directed graph
|
|
/// over a node set of an existing one. This class uses the same
|
|
/// Node type as the underlying graph, and each valid node of the
|
|
/// original graph is valid in this arc set, therefore the node
|
|
/// objects of the original graph can be used directly with this
|
|
/// class. The node handling functions (id handling, observing, and
|
|
/// iterators) works equivalently as in the original graph.
|
|
///
|
|
/// \param GR The type of the graph which shares its node set with
|
|
/// this class. Its interface must conform to the
|
|
/// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
|
|
/// concept.
|
|
///
|
|
/// This implementation is slightly faster than the \c ListArcSet,
|
|
/// because it uses continuous storage for arcs and it uses just
|
|
/// single-linked lists for enumerate outgoing and incoming
|
|
/// arcs. Therefore the arcs cannot be erased from the arc sets.
|
|
///
|
|
/// This class fully conforms to the \ref concepts::Digraph "Digraph"
|
|
/// concept.
|
|
/// It provides only linear time counting for nodes and arcs.
|
|
///
|
|
/// \warning If a node is erased from the underlying graph and this
|
|
/// node is the source or target of one arc in the arc set, then
|
|
/// the arc set is invalidated, and it cannot be used anymore. The
|
|
/// validity can be checked with the \c valid() member function.
|
|
template <typename GR>
|
|
class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
|
|
typedef ArcSetExtender<SmartArcSetBase<GR> > Parent;
|
|
|
|
public:
|
|
|
|
typedef typename Parent::Node Node;
|
|
typedef typename Parent::Arc Arc;
|
|
|
|
protected:
|
|
|
|
typedef typename Parent::NodesImplBase NodesImplBase;
|
|
|
|
void eraseNode(const Node& node) {
|
|
if (typename Parent::InArcIt(*this, node) == INVALID &&
|
|
typename Parent::OutArcIt(*this, node) == INVALID) {
|
|
return;
|
|
}
|
|
throw typename NodesImplBase::Notifier::ImmediateDetach();
|
|
}
|
|
|
|
void clearNodes() {
|
|
Parent::clear();
|
|
}
|
|
|
|
class NodesImpl : public NodesImplBase {
|
|
typedef NodesImplBase Parent;
|
|
|
|
public:
|
|
NodesImpl(const GR& graph, SmartArcSet& arcset)
|
|
: Parent(graph), _arcset(arcset) {}
|
|
|
|
virtual ~NodesImpl() {}
|
|
|
|
bool attached() const {
|
|
return Parent::attached();
|
|
}
|
|
|
|
protected:
|
|
|
|
virtual void erase(const Node& node) {
|
|
try {
|
|
_arcset.eraseNode(node);
|
|
Parent::erase(node);
|
|
} catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
|
|
Parent::clear();
|
|
throw;
|
|
}
|
|
}
|
|
virtual void erase(const std::vector<Node>& nodes) {
|
|
try {
|
|
for (int i = 0; i < int(nodes.size()); ++i) {
|
|
_arcset.eraseNode(nodes[i]);
|
|
}
|
|
Parent::erase(nodes);
|
|
} catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
|
|
Parent::clear();
|
|
throw;
|
|
}
|
|
}
|
|
virtual void clear() {
|
|
_arcset.clearNodes();
|
|
Parent::clear();
|
|
}
|
|
|
|
private:
|
|
SmartArcSet& _arcset;
|
|
};
|
|
|
|
NodesImpl _nodes;
|
|
|
|
public:
|
|
|
|
/// \brief Constructor of the ArcSet.
|
|
///
|
|
/// Constructor of the ArcSet.
|
|
SmartArcSet(const GR& graph) : _nodes(graph, *this) {
|
|
Parent::initalize(graph, _nodes);
|
|
}
|
|
|
|
/// \brief Add a new arc to the digraph.
|
|
///
|
|
/// Add a new arc to the digraph with source node \c s
|
|
/// and target node \c t.
|
|
/// \return The new arc.
|
|
Arc addArc(const Node& s, const Node& t) {
|
|
return Parent::addArc(s, t);
|
|
}
|
|
|
|
/// \brief Validity check
|
|
///
|
|
/// This functions gives back false if the ArcSet is
|
|
/// invalidated. It occurs when a node in the underlying graph is
|
|
/// erased and it is not isolated in the ArcSet.
|
|
bool valid() const {
|
|
return _nodes.attached();
|
|
}
|
|
|
|
};
|
|
|
|
|
|
template <typename GR>
|
|
class SmartEdgeSetBase {
|
|
public:
|
|
|
|
typedef typename GR::Node Node;
|
|
typedef typename GR::NodeIt NodeIt;
|
|
|
|
protected:
|
|
|
|
struct NodeT {
|
|
int first_out;
|
|
NodeT() : first_out(-1) {}
|
|
};
|
|
|
|
typedef typename ItemSetTraits<GR, Node>::
|
|
template Map<NodeT>::Type NodesImplBase;
|
|
|
|
NodesImplBase* _nodes;
|
|
|
|
struct ArcT {
|
|
Node target;
|
|
int next_out;
|
|
ArcT() {}
|
|
};
|
|
|
|
std::vector<ArcT> arcs;
|
|
|
|
const GR* _graph;
|
|
|
|
void initalize(const GR& graph, NodesImplBase& nodes) {
|
|
_graph = &graph;
|
|
_nodes = &nodes;
|
|
}
|
|
|
|
public:
|
|
|
|
class Edge {
|
|
friend class SmartEdgeSetBase;
|
|
protected:
|
|
|
|
int id;
|
|
explicit Edge(int _id) { id = _id;}
|
|
|
|
public:
|
|
Edge() {}
|
|
Edge (Invalid) { id = -1; }
|
|
bool operator==(const Edge& arc) const {return id == arc.id;}
|
|
bool operator!=(const Edge& arc) const {return id != arc.id;}
|
|
bool operator<(const Edge& arc) const {return id < arc.id;}
|
|
};
|
|
|
|
class Arc {
|
|
friend class SmartEdgeSetBase;
|
|
protected:
|
|
Arc(int _id) : id(_id) {}
|
|
int id;
|
|
public:
|
|
operator Edge() const { return edgeFromId(id / 2); }
|
|
|
|
Arc() {}
|
|
Arc(Invalid) : id(-1) {}
|
|
bool operator==(const Arc& arc) const { return id == arc.id; }
|
|
bool operator!=(const Arc& arc) const { return id != arc.id; }
|
|
bool operator<(const Arc& arc) const { return id < arc.id; }
|
|
};
|
|
|
|
SmartEdgeSetBase() {}
|
|
|
|
Node addNode() {
|
|
LEMON_ASSERT(false,
|
|
"This graph structure does not support node insertion");
|
|
return INVALID; // avoid warning
|
|
}
|
|
|
|
Edge addEdge(const Node& u, const Node& v) {
|
|
int n = arcs.size();
|
|
arcs.push_back(ArcT());
|
|
arcs.push_back(ArcT());
|
|
|
|
arcs[n].target = u;
|
|
arcs[n | 1].target = v;
|
|
|
|
arcs[n].next_out = (*_nodes)[v].first_out;
|
|
(*_nodes)[v].first_out = n;
|
|
|
|
arcs[n | 1].next_out = (*_nodes)[u].first_out;
|
|
(*_nodes)[u].first_out = (n | 1);
|
|
|
|
return Edge(n / 2);
|
|
}
|
|
|
|
void clear() {
|
|
Node node;
|
|
for (first(node); node != INVALID; next(node)) {
|
|
(*_nodes)[node].first_out = -1;
|
|
}
|
|
arcs.clear();
|
|
}
|
|
|
|
void first(Node& node) const {
|
|
_graph->first(node);
|
|
}
|
|
|
|
void next(Node& node) const {
|
|
_graph->next(node);
|
|
}
|
|
|
|
void first(Arc& arc) const {
|
|
arc.id = arcs.size() - 1;
|
|
}
|
|
|
|
static void next(Arc& arc) {
|
|
--arc.id;
|
|
}
|
|
|
|
void first(Edge& arc) const {
|
|
arc.id = arcs.size() / 2 - 1;
|
|
}
|
|
|
|
static void next(Edge& arc) {
|
|
--arc.id;
|
|
}
|
|
|
|
void firstOut(Arc& arc, const Node& node) const {
|
|
arc.id = (*_nodes)[node].first_out;
|
|
}
|
|
|
|
void nextOut(Arc& arc) const {
|
|
arc.id = arcs[arc.id].next_out;
|
|
}
|
|
|
|
void firstIn(Arc& arc, const Node& node) const {
|
|
arc.id = (((*_nodes)[node].first_out) ^ 1);
|
|
if (arc.id == -2) arc.id = -1;
|
|
}
|
|
|
|
void nextIn(Arc& arc) const {
|
|
arc.id = ((arcs[arc.id ^ 1].next_out) ^ 1);
|
|
if (arc.id == -2) arc.id = -1;
|
|
}
|
|
|
|
void firstInc(Edge &arc, bool& dir, const Node& node) const {
|
|
int de = (*_nodes)[node].first_out;
|
|
if (de != -1 ) {
|
|
arc.id = de / 2;
|
|
dir = ((de & 1) == 1);
|
|
} else {
|
|
arc.id = -1;
|
|
dir = true;
|
|
}
|
|
}
|
|
void nextInc(Edge &arc, bool& dir) const {
|
|
int de = (arcs[(arc.id * 2) | (dir ? 1 : 0)].next_out);
|
|
if (de != -1 ) {
|
|
arc.id = de / 2;
|
|
dir = ((de & 1) == 1);
|
|
} else {
|
|
arc.id = -1;
|
|
dir = true;
|
|
}
|
|
}
|
|
|
|
static bool direction(Arc arc) {
|
|
return (arc.id & 1) == 1;
|
|
}
|
|
|
|
static Arc direct(Edge edge, bool dir) {
|
|
return Arc(edge.id * 2 + (dir ? 1 : 0));
|
|
}
|
|
|
|
int id(Node node) const { return _graph->id(node); }
|
|
static int id(Arc arc) { return arc.id; }
|
|
static int id(Edge arc) { return arc.id; }
|
|
|
|
Node nodeFromId(int id) const { return _graph->nodeFromId(id); }
|
|
static Arc arcFromId(int id) { return Arc(id); }
|
|
static Edge edgeFromId(int id) { return Edge(id);}
|
|
|
|
int maxNodeId() const { return _graph->maxNodeId(); };
|
|
int maxArcId() const { return arcs.size() - 1; }
|
|
int maxEdgeId() const { return arcs.size() / 2 - 1; }
|
|
|
|
Node source(Arc e) const { return arcs[e.id ^ 1].target; }
|
|
Node target(Arc e) const { return arcs[e.id].target; }
|
|
|
|
Node u(Edge e) const { return arcs[2 * e.id].target; }
|
|
Node v(Edge e) const { return arcs[2 * e.id + 1].target; }
|
|
|
|
typedef typename ItemSetTraits<GR, Node>::ItemNotifier NodeNotifier;
|
|
|
|
NodeNotifier& notifier(Node) const {
|
|
return _graph->notifier(Node());
|
|
}
|
|
|
|
template <typename V>
|
|
class NodeMap : public GR::template NodeMap<V> {
|
|
typedef typename GR::template NodeMap<V> Parent;
|
|
|
|
public:
|
|
|
|
explicit NodeMap(const SmartEdgeSetBase<GR>& arcset)
|
|
: Parent(*arcset._graph) { }
|
|
|
|
NodeMap(const SmartEdgeSetBase<GR>& arcset, const V& value)
|
|
: Parent(*arcset._graph, value) { }
|
|
|
|
NodeMap& operator=(const NodeMap& cmap) {
|
|
return operator=<NodeMap>(cmap);
|
|
}
|
|
|
|
template <typename CMap>
|
|
NodeMap& operator=(const CMap& cmap) {
|
|
Parent::operator=(cmap);
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
};
|
|
|
|
/// \ingroup graphs
|
|
///
|
|
/// \brief Graph using a node set of another digraph or graph and an
|
|
/// own edge set.
|
|
///
|
|
/// This structure can be used to establish another graph over a
|
|
/// node set of an existing one. This class uses the same Node type
|
|
/// as the underlying graph, and each valid node of the original
|
|
/// graph is valid in this arc set, therefore the node objects of
|
|
/// the original graph can be used directly with this class. The
|
|
/// node handling functions (id handling, observing, and iterators)
|
|
/// works equivalently as in the original graph.
|
|
///
|
|
/// \param GR The type of the graph which shares its node set
|
|
/// with this class. Its interface must conform to the
|
|
/// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
|
|
/// concept.
|
|
///
|
|
/// This implementation is slightly faster than the \c ListEdgeSet,
|
|
/// because it uses continuous storage for edges and it uses just
|
|
/// single-linked lists for enumerate incident edges. Therefore the
|
|
/// edges cannot be erased from the edge sets.
|
|
///
|
|
/// This class fully conforms to the \ref concepts::Graph "Graph"
|
|
/// concept.
|
|
/// It provides only linear time counting for nodes, edges and arcs.
|
|
///
|
|
/// \warning If a node is erased from the underlying graph and this
|
|
/// node is incident to one edge in the edge set, then the edge set
|
|
/// is invalidated, and it cannot be used anymore. The validity can
|
|
/// be checked with the \c valid() member function.
|
|
template <typename GR>
|
|
class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {
|
|
typedef EdgeSetExtender<SmartEdgeSetBase<GR> > Parent;
|
|
|
|
public:
|
|
|
|
typedef typename Parent::Node Node;
|
|
typedef typename Parent::Arc Arc;
|
|
typedef typename Parent::Edge Edge;
|
|
|
|
protected:
|
|
|
|
typedef typename Parent::NodesImplBase NodesImplBase;
|
|
|
|
void eraseNode(const Node& node) {
|
|
if (typename Parent::IncEdgeIt(*this, node) == INVALID) {
|
|
return;
|
|
}
|
|
throw typename NodesImplBase::Notifier::ImmediateDetach();
|
|
}
|
|
|
|
void clearNodes() {
|
|
Parent::clear();
|
|
}
|
|
|
|
class NodesImpl : public NodesImplBase {
|
|
typedef NodesImplBase Parent;
|
|
|
|
public:
|
|
NodesImpl(const GR& graph, SmartEdgeSet& arcset)
|
|
: Parent(graph), _arcset(arcset) {}
|
|
|
|
virtual ~NodesImpl() {}
|
|
|
|
bool attached() const {
|
|
return Parent::attached();
|
|
}
|
|
|
|
protected:
|
|
|
|
virtual void erase(const Node& node) {
|
|
try {
|
|
_arcset.eraseNode(node);
|
|
Parent::erase(node);
|
|
} catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
|
|
Parent::clear();
|
|
throw;
|
|
}
|
|
}
|
|
virtual void erase(const std::vector<Node>& nodes) {
|
|
try {
|
|
for (int i = 0; i < int(nodes.size()); ++i) {
|
|
_arcset.eraseNode(nodes[i]);
|
|
}
|
|
Parent::erase(nodes);
|
|
} catch (const typename NodesImplBase::Notifier::ImmediateDetach&) {
|
|
Parent::clear();
|
|
throw;
|
|
}
|
|
}
|
|
virtual void clear() {
|
|
_arcset.clearNodes();
|
|
Parent::clear();
|
|
}
|
|
|
|
private:
|
|
SmartEdgeSet& _arcset;
|
|
};
|
|
|
|
NodesImpl _nodes;
|
|
|
|
public:
|
|
|
|
/// \brief Constructor of the EdgeSet.
|
|
///
|
|
/// Constructor of the EdgeSet.
|
|
SmartEdgeSet(const GR& graph) : _nodes(graph, *this) {
|
|
Parent::initalize(graph, _nodes);
|
|
}
|
|
|
|
/// \brief Add a new edge to the graph.
|
|
///
|
|
/// Add a new edge to the graph with node \c u
|
|
/// and node \c v endpoints.
|
|
/// \return The new edge.
|
|
Edge addEdge(const Node& u, const Node& v) {
|
|
return Parent::addEdge(u, v);
|
|
}
|
|
|
|
/// \brief Validity check
|
|
///
|
|
/// This functions gives back false if the EdgeSet is
|
|
/// invalidated. It occurs when a node in the underlying graph is
|
|
/// erased and it is not isolated in the EdgeSet.
|
|
bool valid() const {
|
|
return _nodes.attached();
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|