20#include <tulip/BasicIterators.h>
22template <
class Tnode,
class Tedge,
class Tprop>
26 nodeDefaultValue = Tnode::defaultValue();
27 edgeDefaultValue = Tedge::defaultValue();
28 nodeProperties.setAll(Tnode::defaultValue());
29 edgeProperties.setAll(Tedge::defaultValue());
30 Tprop::metaValueCalculator =
nullptr;
33template <
class Tnode,
class Tedge,
class Tprop>
34inline typename Tnode::RealType
36 return nodeDefaultValue;
39template <
class Tnode,
class Tedge,
class Tprop>
40inline typename Tedge::RealType
42 return edgeDefaultValue;
45template <
class Tnode,
class Tedge,
class Tprop>
46inline typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue
49 return nodeProperties.get(n.
id);
52template <
class Tnode,
class Tedge,
class Tprop>
53inline typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue
56 return edgeProperties.get(e.
id);
59template <
class Tnode,
class Tedge,
class Tprop>
61 typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue val,
62 const Graph *sg)
const {
68 if (sg == this->graph)
69 it = nodeProperties.findAll(val);
72 return new tlp::SGraphNodeIterator<typename Tnode::RealType>(sg, nodeProperties, val);
74 return (
new tlp::UINTIterator<node>(it));
77template <
class Tnode,
class Tedge,
class Tprop>
79 typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue val,
80 const Graph *sg)
const {
86 if (sg == this->graph)
87 it = edgeProperties.findAll(val);
90 return new tlp::SGraphEdgeIterator<typename Tedge::RealType>(sg, edgeProperties, val);
92 return (
new tlp::UINTIterator<edge>(it));
95template <
class Tnode,
class Tedge,
class Tprop>
97 const tlp::node n,
typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v) {
99 Tprop::notifyBeforeSetNodeValue(n);
100 nodeProperties.set(n.
id, v);
101 Tprop::notifyAfterSetNodeValue(n);
104template <
class Tnode,
class Tedge,
class Tprop>
106 const tlp::edge e,
typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v) {
108 Tprop::notifyBeforeSetEdgeValue(e);
109 edgeProperties.set(e.
id, v);
110 Tprop::notifyAfterSetEdgeValue(e);
113template <
class Tnode,
class Tedge,
class Tprop>
115 typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v) {
116 Tprop::notifyBeforeSetAllNodeValue();
117 nodeDefaultValue = v;
118 nodeProperties.setAll(v);
119 Tprop::notifyAfterSetAllNodeValue();
122template <
class Tnode,
class Tedge,
class Tprop>
124 typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v) {
125 if (nodeDefaultValue == v) {
130 auto oldDefaultValue = nodeDefaultValue;
132 std::vector<tlp::node> nodesOldDefaultToUpdate;
133 std::vector<tlp::node> nodesDefaultToUpdate;
135 for (
auto n : this->getGraph()->nodes()) {
136 auto val = nodeProperties.get(n.id);
138 if (val == oldDefaultValue) {
139 nodesOldDefaultToUpdate.push_back(n);
140 }
else if (val == v) {
141 nodesDefaultToUpdate.push_back(n);
146 nodeDefaultValue = v;
147 nodeProperties.setDefault(v);
151 for (
size_t i = 0; i < nodesOldDefaultToUpdate.size(); ++i) {
152 nodeProperties.set(nodesOldDefaultToUpdate[i].
id, oldDefaultValue);
157 for (
size_t i = 0; i < nodesDefaultToUpdate.size(); ++i) {
158 nodeProperties.set(nodesDefaultToUpdate[i].
id, v,
true);
162template <
class Tnode,
class Tedge,
class Tprop>
164 typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue v,
const Graph *g) {
165 auto graph = this->getGraph();
166 if (v == nodeDefaultValue) {
170 else if (graph->isDescendantGraph(g)) {
171 auto it = getNonDefaultValuatedNodes(g);
173 setNodeValue(it->
next(), v);
177 }
else if (graph == g || graph->isDescendantGraph(g)) {
178 for (
auto n : g->
nodes()) {
184template <
class Tnode,
class Tedge,
class Tprop>
186 typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v) {
187 if (edgeDefaultValue == v) {
192 auto oldDefaultValue = edgeDefaultValue;
194 std::vector<tlp::edge> edgesOldDefaultToUpdate;
196 std::vector<tlp::edge> edgesDefaultToUpdate;
198 for (
auto e : this->getGraph()->edges()) {
199 auto val = edgeProperties.get(e.id);
201 if (val == oldDefaultValue) {
202 edgesOldDefaultToUpdate.push_back(e);
203 }
else if (val == v) {
204 edgesDefaultToUpdate.push_back(e);
209 edgeDefaultValue = v;
210 edgeProperties.setDefault(v);
214 for (
size_t i = 0; i < edgesOldDefaultToUpdate.size(); ++i) {
215 edgeProperties.set(edgesOldDefaultToUpdate[i].
id, oldDefaultValue);
220 for (
size_t i = 0; i < edgesDefaultToUpdate.size(); ++i) {
221 edgeProperties.set(edgesDefaultToUpdate[i].
id, v,
true);
225template <
class Tnode,
class Tedge,
class Tprop>
227 typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v) {
228 Tprop::notifyBeforeSetAllEdgeValue();
229 edgeDefaultValue = v;
230 edgeProperties.setAll(v);
231 Tprop::notifyAfterSetAllEdgeValue();
234template <
class Tnode,
class Tedge,
class Tprop>
236 typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue v,
const Graph *g) {
237 auto graph = this->getGraph();
238 if (v == edgeDefaultValue) {
242 else if (graph->isDescendantGraph(g)) {
243 auto it = getNonDefaultValuatedEdges(g);
245 setEdgeValue(it->
next(), v);
250 for (
auto e : g->
edges()) {
256template <
class Tnode,
class Tedge,
class Tprop>
258 const typename Tnode::RealType &n1Value = getNodeValue(n1);
259 const typename Tnode::RealType &n2Value = getNodeValue(n2);
260 return (n1Value < n2Value) ? -1 : ((n1Value == n2Value) ? 0 : 1);
263template <
class Tnode,
class Tedge,
class Tprop>
265 const typename Tedge::RealType &e1Value = getEdgeValue(e1);
266 const typename Tedge::RealType &e2Value = getEdgeValue(e2);
267 return (e1Value < e2Value) ? -1 : ((e1Value == e2Value) ? 0 : 1);
274template <
typename ELT_TYPE>
277 ELT_TYPE
next()
override {
280 if ((_hasnext = _it->hasNext())) {
283 while (!_graph->isElement(_elt)) {
284 if (!_it->hasNext()) {
296 : _it(it), _graph(g), _elt(ELT_TYPE()), _hasnext(false) {
304 ~GraphEltIterator()
override {
319template <
typename ELT_TYPE,
typename VALUE_TYPE>
320class GraphEltNonDefaultValueIterator :
public tlp::Iterator<ELT_TYPE> {
322 ELT_TYPE
next()
override {
325 if ((_hasnext = _it->hasNext())) {
328 while (_values.get(_elt.id) == _defaultValue) {
329 if (!_it->hasNext()) {
340 GraphEltNonDefaultValueIterator(
342 const tlp::MutableContainer<typename VALUE_TYPE::RealType> &values)
343 : _it(it), _values(values), _elt(ELT_TYPE()), _hasnext(false),
344 _defaultValue(values.getDefault()) {
351 ~GraphEltNonDefaultValueIterator()
override {
357 const tlp::MutableContainer<typename VALUE_TYPE::RealType> &_values;
360 typename tlp::StoredType<typename VALUE_TYPE::RealType>::ReturnedValue _defaultValue;
362#define NB_THRESHOLD(nb) nb / 2
365template <
class Tnode,
class Tedge,
class Tprop>
368 auto nb = nodeProperties.numberOfNonDefaultValues();
374 if (Tprop::name.empty() || (g->
numberOfNodes() > NB_THRESHOLD(nb))) {
376 new tlp::UINTIterator<tlp::node>(nodeProperties.findAll(nodeDefaultValue,
false));
378 if (Tprop::name.empty())
382 return new GraphEltIterator<tlp::node>(g, it);
384 return (g == Tprop::graph) ? it :
new GraphEltIterator<tlp::node>(g, it);
387 return new GraphEltNonDefaultValueIterator<tlp::node, Tnode>(g->
getNodes(), nodeProperties);
390template <
class Tnode,
class Tedge,
class Tprop>
392 if ((g ==
nullptr) || ((g == Tprop::graph) && !Tprop::name.empty())) {
393 return nodeProperties.hasNonDefaultValues();
399template <
class Tnode,
class Tedge,
class Tprop>
402 if ((g ==
nullptr) || ((g == Tprop::graph) && !Tprop::name.empty())) {
403 return nodeProperties.numberOfNonDefaultValues();
409template <
class Tnode,
class Tedge,
class Tprop>
411 return Tnode::valueSize();
414template <
class Tnode,
class Tedge,
class Tprop>
416 Tnode::writeb(oss, nodeDefaultValue);
419template <
class Tnode,
class Tedge,
class Tprop>
422 Tnode::writeb(oss, nodeProperties.get(n.
id));
425template <
class Tnode,
class Tedge,
class Tprop>
427 if (Tnode::readb(iss, nodeDefaultValue)) {
428 nodeProperties.setAll(nodeDefaultValue);
435template <
class Tnode,
class Tedge,
class Tprop>
437 typename Tnode::RealType val;
439 if (Tnode::readb(iss, val)) {
440 nodeProperties.set(n.
id, val);
447template <
class Tnode,
class Tedge,
class Tprop>
450 auto nb = edgeProperties.numberOfNonDefaultValues();
456 if (Tprop::name.empty() || (g->
numberOfEdges() > NB_THRESHOLD(nb))) {
458 new tlp::UINTIterator<tlp::edge>(edgeProperties.findAll(edgeDefaultValue,
false));
460 if (Tprop::name.empty())
464 return new GraphEltIterator<tlp::edge>(g !=
nullptr ? g : Tprop::graph, it);
466 return ((g ==
nullptr) || (g == Tprop::graph)) ? it :
new GraphEltIterator<tlp::edge>(g, it);
469 return new GraphEltNonDefaultValueIterator<tlp::edge, Tedge>(g->
getEdges(), edgeProperties);
472template <
class Tnode,
class Tedge,
class Tprop>
474 if ((g ==
nullptr) || ((g == Tprop::graph) && !Tprop::name.empty())) {
475 return edgeProperties.hasNonDefaultValues();
481template <
class Tnode,
class Tedge,
class Tprop>
484 if ((g ==
nullptr) || ((g == Tprop::graph) && !Tprop::name.empty())) {
485 return edgeProperties.numberOfNonDefaultValues();
491template <
class Tnode,
class Tedge,
class Tprop>
493 return Tedge::valueSize();
496template <
class Tnode,
class Tedge,
class Tprop>
498 Tedge::writeb(oss, edgeDefaultValue);
501template <
class Tnode,
class Tedge,
class Tprop>
504 Tedge::writeb(oss, edgeProperties.get(e.
id));
507template <
class Tnode,
class Tedge,
class Tprop>
509 if (Tedge::readb(iss, edgeDefaultValue)) {
510 edgeProperties.setAll(edgeDefaultValue);
517template <
class Tnode,
class Tedge,
class Tprop>
519 typename Tedge::RealType val;
521 if (Tedge::readb(iss, val)) {
522 edgeProperties.set(e.
id, val);
529template <
typename vectType,
typename eltType,
typename propType>
530tlp::AbstractVectorProperty<vectType, eltType, propType>::AbstractVectorProperty(
532 : AbstractProperty<vectType, vectType, propType>(g, name) {}
534template <
typename vectType,
typename eltType,
typename propType>
535bool tlp::AbstractVectorProperty<vectType, eltType, propType>::tokenize(
536 const std::string &s, std::vector<std::string> &vect,
char openChar,
char sepChar,
538 return vectType::tokenize(s, vect, openChar, sepChar, closeChar);
541template <
typename vectType,
typename eltType,
typename propType>
542bool tlp::AbstractVectorProperty<vectType, eltType, propType>::setNodeStringValueAsVector(
543 const node n,
const std::vector<std::string> &vs) {
544 typename vectType::RealType v;
545 if (!vectType::read(vs, v))
548 this->setNodeValue(n, v);
552template <
typename vectType,
typename eltType,
typename propType>
553bool tlp::AbstractVectorProperty<vectType, eltType, propType>::setNodeStringValueAsVector(
554 const node n,
const std::string &s,
char openChar,
char sepChar,
char closeChar) {
555 typename vectType::RealType v;
556 std::istringstream iss(s);
558 if (!vectType::read(iss, v, openChar, sepChar, closeChar))
561 this->setNodeValue(n, v);
565template <
typename vectType,
typename eltType,
typename propType>
566bool tlp::AbstractVectorProperty<vectType, eltType, propType>::setEdgeStringValueAsVector(
567 const edge e,
const std::vector<std::string> &vs) {
568 typename vectType::RealType v;
569 if (!vectType::read(vs, v))
572 this->setEdgeValue(e, v);
576template <
typename vectType,
typename eltType,
typename propType>
577bool tlp::AbstractVectorProperty<vectType, eltType, propType>::setEdgeStringValueAsVector(
578 const edge e,
const std::string &s,
char openChar,
char sepChar,
char closeChar) {
579 typename vectType::RealType v;
580 std::istringstream iss(s);
582 if (!vectType::read(iss, v, openChar, sepChar, closeChar))
585 this->setEdgeValue(e, v);
589template <
typename vectType,
typename eltType,
typename propType>
590void tlp::AbstractVectorProperty<vectType, eltType, propType>::setNodeEltValue(
591 const node n,
unsigned int i,
592 typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v) {
595 typename vectType::RealType &vect =
596 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n, isNotDefault);
597 assert(vect.size() > i);
598 this->propType::notifyBeforeSetNodeValue(n);
603 typename vectType::RealType tmp(vect);
605 AbstractProperty<vectType, vectType, propType>::nodeProperties.set(n.id, tmp);
608 this->propType::notifyAfterSetNodeValue(n);
611template <
typename vectType,
typename eltType,
typename propType>
612typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue
613tlp::AbstractVectorProperty<vectType, eltType, propType>::getNodeEltValue(
const node n,
614 unsigned int i)
const {
616 const typename vectType::RealType &vect =
617 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n);
618 assert(vect.size() > i);
622template <
typename vectType,
typename eltType,
typename propType>
623void tlp::AbstractVectorProperty<vectType, eltType, propType>::pushBackNodeEltValue(
624 const node n,
typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v) {
627 typename vectType::RealType &vect =
628 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n, isNotDefault);
629 this->propType::notifyBeforeSetNodeValue(n);
634 typename vectType::RealType tmp(vect);
636 AbstractProperty<vectType, vectType, propType>::nodeProperties.set(n, tmp);
639 this->propType::notifyAfterSetNodeValue(n);
642template <
typename vectType,
typename eltType,
typename propType>
643void tlp::AbstractVectorProperty<vectType, eltType, propType>::popBackNodeEltValue(
const node n) {
646 typename vectType::RealType &vect =
647 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n, isNotDefault);
648 this->propType::notifyBeforeSetNodeValue(n);
649 assert(isNotDefault);
651 this->propType::notifyAfterSetNodeValue(n);
654template <
typename vectType,
typename eltType,
typename propType>
655void tlp::AbstractVectorProperty<vectType, eltType, propType>::resizeNodeValue(
656 const node n,
size_t size,
typename eltType::RealType elt) {
659 typename vectType::RealType &vect =
660 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n, isNotDefault);
661 assert(isNotDefault);
662 this->propType::notifyBeforeSetNodeValue(n);
663 vect.resize(size, elt);
664 this->propType::notifyAfterSetNodeValue(n);
667template <
typename vectType,
typename eltType,
typename propType>
668void tlp::AbstractVectorProperty<vectType, eltType, propType>::setEdgeEltValue(
669 const edge e,
unsigned int i,
670 typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v) {
673 typename vectType::RealType &vect =
674 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e, isNotDefault);
675 assert(vect.size() > i);
676 this->propType::notifyBeforeSetEdgeValue(e);
681 typename vectType::RealType tmp(vect);
683 AbstractProperty<vectType, vectType, propType>::edgeProperties.set(e, tmp);
686 this->propType::notifyAfterSetEdgeValue(e);
689template <
typename vectType,
typename eltType,
typename propType>
690typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue
691tlp::AbstractVectorProperty<vectType, eltType, propType>::getEdgeEltValue(
const edge e,
692 unsigned int i)
const {
694 const typename vectType::RealType &vect =
695 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e);
696 assert(vect.size() > i);
699template <
typename vectType,
typename eltType,
typename propType>
700void tlp::AbstractVectorProperty<vectType, eltType, propType>::pushBackEdgeEltValue(
701 const edge e,
typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v) {
704 typename vectType::RealType &vect =
705 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e, isNotDefault);
706 this->propType::notifyBeforeSetEdgeValue(e);
711 typename vectType::RealType tmp(vect);
713 AbstractProperty<vectType, vectType, propType>::edgeProperties.set(e, tmp);
716 this->propType::notifyAfterSetEdgeValue(e);
719template <
typename vectType,
typename eltType,
typename propType>
720void tlp::AbstractVectorProperty<vectType, eltType, propType>::popBackEdgeEltValue(
const edge e) {
723 typename vectType::RealType &vect =
724 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e, isNotDefault);
725 this->propType::notifyBeforeSetEdgeValue(e);
726 assert(isNotDefault);
728 this->propType::notifyAfterSetEdgeValue(e);
731template <
typename vectType,
typename eltType,
typename propType>
732void tlp::AbstractVectorProperty<vectType, eltType, propType>::resizeEdgeValue(
733 const edge e,
size_t size,
typename eltType::RealType elt) {
736 typename vectType::RealType &vect =
737 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e, isNotDefault);
738 assert(isNotDefault);
739 this->propType::notifyBeforeSetEdgeValue(e);
740 vect.resize(size, elt);
741 this->propType::notifyAfterSetEdgeValue(e);
This class extends upon PropertyInterface, and adds type-safe methods to get and set the node and edg...
void writeEdgeValue(std::ostream &, edge) const override
Writes the value of an edge.
virtual void setAllEdgeValue(typename tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue v)
Sets the value of all edges and notify the observers. All previous values are lost and the given valu...
void writeNodeValue(std::ostream &, node) const override
Writes the value of a node.
bool readEdgeValue(std::istream &, edge) override
Reads the value of an edge.
virtual void setEdgeValue(const edge e, typename tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue v)
Set the value of an edge and notify the observers of a modification.
tlp::Iterator< node > * getNonDefaultValuatedNodes(const Graph *g=nullptr) const override
Gets an Iterator on all non-default valuated nodes. When given a Graph as parameter,...
tlp::StoredType< typenameTedge::RealType >::ReturnedConstValue getEdgeValue(const edge e) const
Returns the value associated to the edge e in this property. If there is no value,...
virtual void setAllNodeValue(typename tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue v)
Sets the value of all nodes and notify the observers. All previous values are lost and the given valu...
unsigned int edgeValueSize() const override
Returns the size in bytes of an edge's value.
bool hasNonDefaultValuatedEdges(const Graph *g=nullptr) const override
Returns whether the property has edges with a non default value. When given a Graph as parameter,...
bool readEdgeDefaultValue(std::istream &) override
Reads the edges default value.
virtual tlp::Iterator< node > * getNodesEqualTo(typename tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue v, const Graph *g=nullptr) const
virtual void setEdgeDefaultValue(typename tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue v)
Sets the value assigned as the default one to the future added edges.
virtual void setValueToGraphNodes(typename tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue v, const Graph *graph)
Sets the value of all nodes in a graph and notify the observers. Only the nodes from that graph will ...
void writeEdgeDefaultValue(std::ostream &) const override
Writes the edges default value.
Tnode::RealType getNodeDefaultValue() const
Gets the default node value of the property.
bool hasNonDefaultValuatedNodes(const Graph *g=nullptr) const override
Returns whether the property has nodes with a non default value. When given a Graph as parameter,...
virtual void setNodeValue(const node n, typename tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue v)
Sets the value of a node and notify the observers of a modification.
unsigned int numberOfNonDefaultValuatedEdges(const Graph *=nullptr) const override
Returns the number of edges with a non default value.
unsigned int nodeValueSize() const override
Returns the size in bytes of a node's value.
tlp::StoredType< typenameTnode::RealType >::ReturnedConstValue getNodeValue(const node n) const
Returns the value associated with the node n in this property. If there is no value,...
virtual void setNodeDefaultValue(typename tlp::StoredType< typename Tnode::RealType >::ReturnedConstValue v)
Sets the value assigned as the default one to the future added nodes.
unsigned int numberOfNonDefaultValuatedNodes(const Graph *g=nullptr) const override
Returns the number of nodes with a non default value. When given a Graph as parameter,...
virtual void setValueToGraphEdges(typename tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue v, const Graph *graph)
Sets the value of all edges in a graph and notify the observers. Only the edges from that graph will ...
Tedge::RealType getEdgeDefaultValue() const
Gets the default edge value of the property.
bool readNodeDefaultValue(std::istream &) override
Reads the nodes default value.
int compare(const node n1, const node n2) const override
Compares the value this property holds for the two given nodes.
tlp::Iterator< edge > * getNonDefaultValuatedEdges(const Graph *g=nullptr) const override
Gets an Iterator on all non-default valuated edges. When given a Graph as parameter,...
virtual tlp::Iterator< edge > * getEdgesEqualTo(typename tlp::StoredType< typename Tedge::RealType >::ReturnedConstValue v, const Graph *g=nullptr) const
void writeNodeDefaultValue(std::ostream &) const override
Writes the nodes default value.
bool readNodeValue(std::istream &, node) override
Reads the value of a node.
virtual bool isDescendantGraph(const Graph *subGraph) const =0
Indicates if the graph argument is a descendant of this graph.
virtual const std::vector< edge > & edges() const =0
Return a const reference on the vector of edges of the graph It is the fastest way to access to edges...
virtual const std::vector< node > & nodes() const =0
Return a const reference on the vector of nodes of the graph It is the fastest way to access to nodes...
virtual unsigned int numberOfNodes() const =0
Gets the number of nodes in this graph.
virtual unsigned int numberOfEdges() const =0
Gets the number of edges in this graph.
virtual Iterator< edge > * getEdges() const =0
Get an iterator over all the graph's edges.
virtual Iterator< node > * getNodes() const =0
Gets an iterator over this graph's nodes.
bool iteratorEmpty(Iterator< T > *it)
Checks if an iterator is empty.
unsigned int iteratorCount(Iterator< T > *it)
Counts the number of iterated elements.
Interface for Tulip iterators. Allows basic iteration operations only.
virtual bool hasNext()=0
Tells if the sequence is at its end.
virtual T next()=0
Moves the Iterator on the next element.
The edge struct represents an edge in a Graph object.
bool isValid() const
isValid checks if the edge is valid. An invalid edge is an edge whose id is UINT_MAX.
unsigned int id
id The identifier of the edge.
The node struct represents a node in a Graph object.
unsigned int id
id The identifier of the node.
bool isValid() const
isValid checks if the node is valid. An invalid node is a node whose id is UINT_MAX.