lemon/concepts/graph_components.h
changeset 1259 8b2d4e5d96e4
parent 1173 d216e1c8b3fa
parent 1257 3e711ee55d31
child 1263 b9887ae63df0
child 1261 97f1760dcd13
equal deleted inserted replaced
31:fd26059dacb7 41:e3fc7e54126a
   106           _GraphItem i3 = INVALID;
   106           _GraphItem i3 = INVALID;
   107 
   107 
   108           i1 = i2 = i3;
   108           i1 = i2 = i3;
   109 
   109 
   110           bool b;
   110           bool b;
   111           ignore_unused_variable_warning(b);
   111           ::lemon::ignore_unused_variable_warning(b);
   112 
   112 
   113           b = (ia == ib) && (ia != ib);
   113           b = (ia == ib) && (ia != ib);
   114           b = (ia == INVALID) && (ib != INVALID);
   114           b = (ia == INVALID) && (ib != INVALID);
   115           b = (ia < ib);
   115           b = (ia < ib);
   116         }
   116         }
   287             e = graph.direct(ue, false);
   287             e = graph.direct(ue, false);
   288             e = graph.direct(ue, n);
   288             e = graph.direct(ue, n);
   289             e = graph.oppositeArc(e);
   289             e = graph.oppositeArc(e);
   290             ue = e;
   290             ue = e;
   291             bool d = graph.direction(e);
   291             bool d = graph.direction(e);
   292             ignore_unused_variable_warning(d);
   292             ::lemon::ignore_unused_variable_warning(d);
   293           }
   293           }
   294         }
   294         }
   295 
   295 
   296         const _Graph& graph;
   296         const _Graph& graph;
   297       Constraints() {}
   297       Constraints() {}
   366           int eid = digraph.id(arc);
   366           int eid = digraph.id(arc);
   367           eid = digraph.id(arc);
   367           eid = digraph.id(arc);
   368           arc = digraph.arcFromId(eid);
   368           arc = digraph.arcFromId(eid);
   369 
   369 
   370           nid = digraph.maxNodeId();
   370           nid = digraph.maxNodeId();
   371           ignore_unused_variable_warning(nid);
   371           ::lemon::ignore_unused_variable_warning(nid);
   372           eid = digraph.maxArcId();
   372           eid = digraph.maxArcId();
   373           ignore_unused_variable_warning(eid);
   373           ::lemon::ignore_unused_variable_warning(eid);
   374         }
   374         }
   375 
   375 
   376         const _Digraph& digraph;
   376         const _Digraph& digraph;
   377         Constraints() {}
   377         Constraints() {}
   378       };
   378       };
   421           typename _Graph::Edge edge;
   421           typename _Graph::Edge edge;
   422           int ueid = graph.id(edge);
   422           int ueid = graph.id(edge);
   423           ueid = graph.id(edge);
   423           ueid = graph.id(edge);
   424           edge = graph.edgeFromId(ueid);
   424           edge = graph.edgeFromId(ueid);
   425           ueid = graph.maxEdgeId();
   425           ueid = graph.maxEdgeId();
   426           ignore_unused_variable_warning(ueid);
   426           ::lemon::ignore_unused_variable_warning(ueid);
   427         }
   427         }
   428 
   428 
   429         const _Graph& graph;
   429         const _Graph& graph;
   430         Constraints() {}
   430         Constraints() {}
   431       };
   431       };
   494           checkConcept<GraphItem<>, _GraphItemIt>();
   494           checkConcept<GraphItem<>, _GraphItemIt>();
   495           _GraphItemIt it1(g);
   495           _GraphItemIt it1(g);
   496           _GraphItemIt it2;
   496           _GraphItemIt it2;
   497           _GraphItemIt it3 = it1;
   497           _GraphItemIt it3 = it1;
   498           _GraphItemIt it4 = INVALID;
   498           _GraphItemIt it4 = INVALID;
   499           ignore_unused_variable_warning(it3);
   499           ::lemon::ignore_unused_variable_warning(it3);
   500           ignore_unused_variable_warning(it4);
   500           ::lemon::ignore_unused_variable_warning(it4);
   501 
   501 
   502           it2 = ++it1;
   502           it2 = ++it1;
   503           ++it2 = it1;
   503           ++it2 = it1;
   504           ++(++it1);
   504           ++(++it1);
   505 
   505 
   585           checkConcept<GraphItem<sel>, _GraphIncIt>();
   585           checkConcept<GraphItem<sel>, _GraphIncIt>();
   586           _GraphIncIt it1(graph, node);
   586           _GraphIncIt it1(graph, node);
   587           _GraphIncIt it2;
   587           _GraphIncIt it2;
   588           _GraphIncIt it3 = it1;
   588           _GraphIncIt it3 = it1;
   589           _GraphIncIt it4 = INVALID;
   589           _GraphIncIt it4 = INVALID;
   590           ignore_unused_variable_warning(it3);
   590           ::lemon::ignore_unused_variable_warning(it3);
   591           ignore_unused_variable_warning(it4);
   591           ::lemon::ignore_unused_variable_warning(it4);
   592 
   592 
   593           it2 = ++it1;
   593           it2 = ++it1;
   594           ++it2 = it1;
   594           ++it2 = it1;
   595           ++(++it1);
   595           ++(++it1);
   596           Item e = it1;
   596           Item e = it1;
   768             const typename _Digraph::OutArcIt oait(INVALID);
   768             const typename _Digraph::OutArcIt oait(INVALID);
   769             n = digraph.baseNode(iait);
   769             n = digraph.baseNode(iait);
   770             n = digraph.runningNode(iait);
   770             n = digraph.runningNode(iait);
   771             n = digraph.baseNode(oait);
   771             n = digraph.baseNode(oait);
   772             n = digraph.runningNode(oait);
   772             n = digraph.runningNode(oait);
   773             ignore_unused_variable_warning(n);
   773             ::lemon::ignore_unused_variable_warning(n);
   774           }
   774           }
   775         }
   775         }
   776 
   776 
   777         const _Digraph& digraph;
   777         const _Digraph& digraph;
   778         Constraints() {}
   778         Constraints() {}
   951             = digraph.notifier(typename _Digraph::Node());
   951             = digraph.notifier(typename _Digraph::Node());
   952 
   952 
   953           typename _Digraph::ArcNotifier& en
   953           typename _Digraph::ArcNotifier& en
   954             = digraph.notifier(typename _Digraph::Arc());
   954             = digraph.notifier(typename _Digraph::Arc());
   955 
   955 
   956           ignore_unused_variable_warning(nn);
   956           ::lemon::ignore_unused_variable_warning(nn);
   957           ignore_unused_variable_warning(en);
   957           ::lemon::ignore_unused_variable_warning(en);
   958         }
   958         }
   959 
   959 
   960         const _Digraph& digraph;
   960         const _Digraph& digraph;
   961         Constraints() {}
   961         Constraints() {}
   962       };
   962       };
   994       struct Constraints {
   994       struct Constraints {
   995         void constraints() {
   995         void constraints() {
   996           checkConcept<AlterableDigraphComponent<Base>, _Graph>();
   996           checkConcept<AlterableDigraphComponent<Base>, _Graph>();
   997           typename _Graph::EdgeNotifier& uen
   997           typename _Graph::EdgeNotifier& uen
   998             = graph.notifier(typename _Graph::Edge());
   998             = graph.notifier(typename _Graph::Edge());
   999           ignore_unused_variable_warning(uen);
   999           ::lemon::ignore_unused_variable_warning(uen);
  1000         }
  1000         }
  1001 
  1001 
  1002         const _Graph& graph;
  1002         const _Graph& graph;
  1003         Constraints() {}
  1003         Constraints() {}
  1004       };
  1004       };
  1068 
  1068 
  1069           // Assignment operator
  1069           // Assignment operator
  1070           // ReadMap<Key, Value> cmap;
  1070           // ReadMap<Key, Value> cmap;
  1071           // m3 = cmap;
  1071           // m3 = cmap;
  1072 
  1072 
  1073           ignore_unused_variable_warning(m1);
  1073           ::lemon::ignore_unused_variable_warning(m1);
  1074           ignore_unused_variable_warning(m2);
  1074           ::lemon::ignore_unused_variable_warning(m2);
  1075           // ignore_unused_variable_warning(m3);
  1075           // ::lemon::ignore_unused_variable_warning(m3);
  1076         }
  1076         }
  1077 
  1077 
  1078         const _Map &m;
  1078         const _Map &m;
  1079         const GR &g;
  1079         const GR &g;
  1080         const typename GraphMap::Value &t;
  1080         const typename GraphMap::Value &t;