20 #include <tulip/BasicIterators.h>
22 template <
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;
33 template <
class Tnode,
class Tedge,
class Tprop>
34 inline typename Tnode::RealType
36 return nodeDefaultValue;
39 template <
class Tnode,
class Tedge,
class Tprop>
40 inline typename Tedge::RealType
42 return edgeDefaultValue;
45 template <
class Tnode,
class Tedge,
class Tprop>
46 inline typename tlp::StoredType<typename Tnode::RealType>::ReturnedConstValue
49 return nodeProperties.get(n.
id);
52 template <
class Tnode,
class Tedge,
class Tprop>
53 inline typename tlp::StoredType<typename Tedge::RealType>::ReturnedConstValue
56 return edgeProperties.get(e.
id);
59 template <
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));
77 template <
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));
95 template <
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);
104 template <
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);
113 template <
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();
122 template <
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);
162 template <
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);
172 while (it->hasNext()) {
173 setNodeValue(it->next(), v);
178 for (
auto n : g->
nodes()) {
184 template <
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);
225 template <
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();
234 template <
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);
244 while (it->hasNext()) {
245 setEdgeValue(it->next(), v);
250 for (
auto e : g->
edges()) {
256 template <
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);
263 template <
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);
274 template <
typename ELT_TYPE>
277 ELT_TYPE
next()
override {
278 ELT_TYPE tmp = curElt;
280 if ((_hasnext = it->hasNext())) {
283 while (!(_hasnext = (!graph || graph->isElement(curElt)))) {
294 : it(itN), graph(g), curElt(ELT_TYPE()), _hasnext(false) {
301 ~GraphEltIterator()
override {
314 template <
class Tnode,
class Tedge,
class Tprop>
318 new tlp::UINTIterator<tlp::node>(nodeProperties.findAll(nodeDefaultValue,
false));
320 if (Tprop::name.empty())
324 return new GraphEltIterator<tlp::node>(g !=
nullptr ? g : Tprop::graph, it);
326 return ((g ==
nullptr) || (g == Tprop::graph)) ? it :
new GraphEltIterator<tlp::node>(g, it);
329 template <
class Tnode,
class Tedge,
class Tprop>
332 return nodeProperties.hasNonDefaultValues();
338 template <
class Tnode,
class Tedge,
class Tprop>
342 return nodeProperties.numberOfNonDefaultValues();
348 template <
class Tnode,
class Tedge,
class Tprop>
350 return Tnode::valueSize();
353 template <
class Tnode,
class Tedge,
class Tprop>
355 Tnode::writeb(oss, nodeDefaultValue);
358 template <
class Tnode,
class Tedge,
class Tprop>
361 Tnode::writeb(oss, nodeProperties.get(n.
id));
364 template <
class Tnode,
class Tedge,
class Tprop>
366 if (Tnode::readb(iss, nodeDefaultValue)) {
367 nodeProperties.setAll(nodeDefaultValue);
374 template <
class Tnode,
class Tedge,
class Tprop>
376 typename Tnode::RealType val;
378 if (Tnode::readb(iss, val)) {
379 nodeProperties.set(n.
id, val);
386 template <
class Tnode,
class Tedge,
class Tprop>
390 new tlp::UINTIterator<tlp::edge>(edgeProperties.findAll(edgeDefaultValue,
false));
392 if (Tprop::name.empty())
396 return new GraphEltIterator<tlp::edge>(g !=
nullptr ? g : Tprop::graph, it);
398 return ((g ==
nullptr) || (g == Tprop::graph)) ? it :
new GraphEltIterator<tlp::edge>(g, it);
401 template <
class Tnode,
class Tedge,
class Tprop>
404 return edgeProperties.hasNonDefaultValues();
410 template <
class Tnode,
class Tedge,
class Tprop>
414 return edgeProperties.numberOfNonDefaultValues();
420 template <
class Tnode,
class Tedge,
class Tprop>
422 return Tedge::valueSize();
425 template <
class Tnode,
class Tedge,
class Tprop>
427 Tedge::writeb(oss, edgeDefaultValue);
430 template <
class Tnode,
class Tedge,
class Tprop>
433 Tedge::writeb(oss, edgeProperties.get(e.
id));
436 template <
class Tnode,
class Tedge,
class Tprop>
438 if (Tedge::readb(iss, edgeDefaultValue)) {
439 edgeProperties.setAll(edgeDefaultValue);
446 template <
class Tnode,
class Tedge,
class Tprop>
448 typename Tedge::RealType val;
450 if (Tedge::readb(iss, val)) {
451 edgeProperties.set(e.
id, val);
458 template <
typename vectType,
typename eltType,
typename propType>
459 tlp::AbstractVectorProperty<vectType, eltType, propType>::AbstractVectorProperty(
463 template <
typename vectType,
typename eltType,
typename propType>
464 bool tlp::AbstractVectorProperty<vectType, eltType, propType>::tokenize(
465 const std::string &s, std::vector<std::string> &vect,
char openChar,
char sepChar,
467 return vectType::tokenize(s, vect, openChar, sepChar, closeChar);
470 template <
typename vectType,
typename eltType,
typename propType>
471 bool tlp::AbstractVectorProperty<vectType, eltType, propType>::setNodeStringValueAsVector(
472 const node n,
const std::vector<std::string> &vs) {
473 typename vectType::RealType v;
474 if (!vectType::read(vs, v))
477 this->setNodeValue(n, v);
481 template <
typename vectType,
typename eltType,
typename propType>
482 bool tlp::AbstractVectorProperty<vectType, eltType, propType>::setNodeStringValueAsVector(
483 const node n,
const std::string &s,
char openChar,
char sepChar,
char closeChar) {
484 typename vectType::RealType v;
485 std::istringstream iss(s);
487 if (!vectType::read(iss, v, openChar, sepChar, closeChar))
490 this->setNodeValue(n, v);
494 template <
typename vectType,
typename eltType,
typename propType>
495 bool tlp::AbstractVectorProperty<vectType, eltType, propType>::setEdgeStringValueAsVector(
496 const edge e,
const std::vector<std::string> &vs) {
497 typename vectType::RealType v;
498 if (!vectType::read(vs, v))
501 this->setEdgeValue(e, v);
505 template <
typename vectType,
typename eltType,
typename propType>
506 bool tlp::AbstractVectorProperty<vectType, eltType, propType>::setEdgeStringValueAsVector(
507 const edge e,
const std::string &s,
char openChar,
char sepChar,
char closeChar) {
508 typename vectType::RealType v;
509 std::istringstream iss(s);
511 if (!vectType::read(iss, v, openChar, sepChar, closeChar))
514 this->setEdgeValue(e, v);
518 template <
typename vectType,
typename eltType,
typename propType>
519 void tlp::AbstractVectorProperty<vectType, eltType, propType>::setNodeEltValue(
520 const node n,
unsigned int i,
521 typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v) {
524 typename vectType::RealType &vect =
525 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n, isNotDefault);
526 assert(vect.size() > i);
527 this->propType::notifyBeforeSetNodeValue(n);
532 typename vectType::RealType tmp(vect);
534 AbstractProperty<vectType, vectType, propType>::nodeProperties.set(n.id, tmp);
537 this->propType::notifyAfterSetNodeValue(n);
540 template <
typename vectType,
typename eltType,
typename propType>
541 typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue
542 tlp::AbstractVectorProperty<vectType, eltType, propType>::getNodeEltValue(
const node n,
543 unsigned int i)
const {
545 const typename vectType::RealType &vect =
546 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n);
547 assert(vect.size() > i);
551 template <
typename vectType,
typename eltType,
typename propType>
552 void tlp::AbstractVectorProperty<vectType, eltType, propType>::pushBackNodeEltValue(
553 const node n,
typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v) {
556 typename vectType::RealType &vect =
557 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n, isNotDefault);
558 this->propType::notifyBeforeSetNodeValue(n);
563 typename vectType::RealType tmp(vect);
565 AbstractProperty<vectType, vectType, propType>::nodeProperties.set(n, tmp);
568 this->propType::notifyAfterSetNodeValue(n);
571 template <
typename vectType,
typename eltType,
typename propType>
572 void tlp::AbstractVectorProperty<vectType, eltType, propType>::popBackNodeEltValue(
const node n) {
575 typename vectType::RealType &vect =
576 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n, isNotDefault);
577 this->propType::notifyBeforeSetNodeValue(n);
578 assert(isNotDefault);
580 this->propType::notifyAfterSetNodeValue(n);
583 template <
typename vectType,
typename eltType,
typename propType>
584 void tlp::AbstractVectorProperty<vectType, eltType, propType>::resizeNodeValue(
585 const node n,
size_t size,
typename eltType::RealType elt) {
588 typename vectType::RealType &vect =
589 AbstractProperty<vectType, vectType, propType>::nodeProperties.get(n, isNotDefault);
590 assert(isNotDefault);
591 this->propType::notifyBeforeSetNodeValue(n);
592 vect.resize(size, elt);
593 this->propType::notifyAfterSetNodeValue(n);
596 template <
typename vectType,
typename eltType,
typename propType>
597 void tlp::AbstractVectorProperty<vectType, eltType, propType>::setEdgeEltValue(
598 const edge e,
unsigned int i,
599 typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v) {
602 typename vectType::RealType &vect =
603 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e, isNotDefault);
604 assert(vect.size() > i);
605 this->propType::notifyBeforeSetEdgeValue(e);
610 typename vectType::RealType tmp(vect);
612 AbstractProperty<vectType, vectType, propType>::edgeProperties.set(e, tmp);
615 this->propType::notifyAfterSetEdgeValue(e);
618 template <
typename vectType,
typename eltType,
typename propType>
619 typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue
620 tlp::AbstractVectorProperty<vectType, eltType, propType>::getEdgeEltValue(
const edge e,
621 unsigned int i)
const {
623 const typename vectType::RealType &vect =
624 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e);
625 assert(vect.size() > i);
628 template <
typename vectType,
typename eltType,
typename propType>
629 void tlp::AbstractVectorProperty<vectType, eltType, propType>::pushBackEdgeEltValue(
630 const edge e,
typename tlp::StoredType<typename eltType::RealType>::ReturnedConstValue v) {
633 typename vectType::RealType &vect =
634 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e, isNotDefault);
635 this->propType::notifyBeforeSetEdgeValue(e);
640 typename vectType::RealType tmp(vect);
642 AbstractProperty<vectType, vectType, propType>::edgeProperties.set(e, tmp);
645 this->propType::notifyAfterSetEdgeValue(e);
648 template <
typename vectType,
typename eltType,
typename propType>
649 void tlp::AbstractVectorProperty<vectType, eltType, propType>::popBackEdgeEltValue(
const edge e) {
652 typename vectType::RealType &vect =
653 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e, isNotDefault);
654 this->propType::notifyBeforeSetEdgeValue(e);
655 assert(isNotDefault);
657 this->propType::notifyAfterSetEdgeValue(e);
660 template <
typename vectType,
typename eltType,
typename propType>
661 void tlp::AbstractVectorProperty<vectType, eltType, propType>::resizeEdgeValue(
662 const edge e,
size_t size,
typename eltType::RealType elt) {
665 typename vectType::RealType &vect =
666 AbstractProperty<vectType, vectType, propType>::edgeProperties.get(e, isNotDefault);
667 assert(isNotDefault);
668 this->propType::notifyBeforeSetEdgeValue(e);
669 vect.resize(size, elt);
670 this->propType::notifyAfterSetEdgeValue(e);