1.1 --- a/src/work/list_graph.h Fri Mar 19 22:16:05 2004 +0000
1.2 +++ b/src/work/list_graph.h Sat Mar 20 11:19:00 2004 +0000
1.3 @@ -428,7 +428,7 @@
1.4 friend class ListGraph;
1.5 //protected:
1.6 public: //for alpar
1.7 - EdgeIt(const ListGraph&) {
1.8 + EdgeIt(const ListGraph& G) {
1.9 node_item* v=G._first_node;
1.10 if (v) edge=v->_first_out_edge; else edge=0;
1.11 while (v && !edge) { v=v->_next_node; if (v) edge=v->_first_out_edge; }
2.1 --- a/src/work/marci/graph_wrapper.h Fri Mar 19 22:16:05 2004 +0000
2.2 +++ b/src/work/marci/graph_wrapper.h Sat Mar 20 11:19:00 2004 +0000
2.3 @@ -29,19 +29,19 @@
2.4 void setGraph(Graph& _graph) { graph = &_graph; }
2.5 Graph& getGraph() const { return (*graph); }
2.6
2.7 - template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
2.8 - template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
2.9 - return graph->/*getF*/first(i, p); }
2.10 + template<typename I> I& first(I& i) const { return graph->first(i); }
2.11 + template<typename I, typename P> I& first(I& i, const P& p) const {
2.12 + return graph->first(i, p); }
2.13
2.14 template<typename I> I getNext(const I& i) const {
2.15 return graph->getNext(i); }
2.16 template<typename I> I& next(I &i) const { return graph->next(i); }
2.17
2.18 template< typename It > It first() const {
2.19 - It e; /*getF*/first(e); return e; }
2.20 + It e; first(e); return e; }
2.21
2.22 template< typename It > It first(const Node& v) const {
2.23 - It e; /*getF*/first(e, v); return e; }
2.24 + It e; first(e, v); return e; }
2.25
2.26 Node head(const Edge& e) const { return graph->head(e); }
2.27 Node tail(const Edge& e) const { return graph->tail(e); }
2.28 @@ -85,6 +85,81 @@
2.29 };
2.30 };
2.31
2.32 + template<typename GraphWrapper>
2.33 + class GraphWrapperSkeleton {
2.34 + protected:
2.35 + GraphWrapper gw;
2.36 +
2.37 + public:
2.38 + typedef typename GraphWrapper::BaseGraph BaseGraph;
2.39 +
2.40 + typedef typename GraphWrapper::Node Node;
2.41 + typedef typename GraphWrapper::NodeIt NodeIt;
2.42 +
2.43 + typedef typename GraphWrapper::Edge Edge;
2.44 + typedef typename GraphWrapper::OutEdgeIt OutEdgeIt;
2.45 + typedef typename GraphWrapper::InEdgeIt InEdgeIt;
2.46 + //typedef typename GraphWrapper::SymEdgeIt SymEdgeIt;
2.47 + typedef typename GraphWrapper::EdgeIt EdgeIt;
2.48 +
2.49 + //GraphWrapperSkeleton() : gw() { }
2.50 + GraphWrapperSkeleton(GraphWrapper& _gw) : gw(_gw) { }
2.51 +
2.52 + void setGraph(BaseGraph& _graph) { gw.setGraph(_graph); }
2.53 + BaseGraph& getGraph() const { return gw.getGraph(); }
2.54 +
2.55 + template<typename I> I& first(I& i) const { return gw.first(i); }
2.56 + template<typename I, typename P> I& first(I& i, const P& p) const {
2.57 + return gw.first(i, p); }
2.58 +
2.59 + template<typename I> I getNext(const I& i) const { return gw.getNext(i); }
2.60 + template<typename I> I& next(I &i) const { return gw.next(i); }
2.61 +
2.62 + template< typename It > It first() const {
2.63 + It e; this->first(e); return e; }
2.64 +
2.65 + template< typename It > It first(const Node& v) const {
2.66 + It e; this->first(e, v); return e; }
2.67 +
2.68 + Node head(const Edge& e) const { return gw.head(e); }
2.69 + Node tail(const Edge& e) const { return gw.tail(e); }
2.70 +
2.71 + template<typename I> bool valid(const I& i) const { return gw.valid(i); }
2.72 +
2.73 + //template<typename I> void setInvalid(const I &i);
2.74 + //{ return graph->setInvalid(i); }
2.75 +
2.76 + int nodeNum() const { return gw.nodeNum(); }
2.77 + int edgeNum() const { return gw.edgeNum(); }
2.78 +
2.79 + template<typename I> Node aNode(const I& e) const { return gw.aNode(e); }
2.80 + template<typename I> Node bNode(const I& e) const { return gw.bNode(e); }
2.81 +
2.82 + Node addNode() const { return gw.addNode(); }
2.83 + Edge addEdge(const Node& tail, const Node& head) const {
2.84 + return gw.addEdge(tail, head); }
2.85 +
2.86 + template<typename I> void erase(const I& i) const { gw.erase(i); }
2.87 +
2.88 + void clear() const { gw.clear(); }
2.89 +
2.90 + template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> {
2.91 + public:
2.92 + NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) :
2.93 + GraphWrapper::NodeMap<T>(_G.gw) { }
2.94 + NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) :
2.95 + GraphWrapper::NodeMap<T>(_G.gw, a) { }
2.96 + };
2.97 +
2.98 + template<typename T> class EdgeMap : public GraphWrapper::EdgeMap<T> {
2.99 + public:
2.100 + EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) :
2.101 + GraphWrapper::EdgeMap<T>(_G.gw) { }
2.102 + EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) :
2.103 + GraphWrapper::EdgeMap<T>(_G.gw, a) { }
2.104 + };
2.105 + };
2.106 +
2.107 template<typename Graph>
2.108 class RevGraphWrapper
2.109 {
2.110 @@ -109,19 +184,19 @@
2.111 void setGraph(Graph& _graph) { graph = &_graph; }
2.112 Graph& getGraph() const { return (*graph); }
2.113
2.114 - template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
2.115 - template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
2.116 - return graph->/*getF*/first(i, p); }
2.117 + template<typename I> I& first(I& i) const { return graph->first(i); }
2.118 + template<typename I, typename P> I& first(I& i, const P& p) const {
2.119 + return graph->first(i, p); }
2.120
2.121 template<typename I> I getNext(const I& i) const {
2.122 return graph->getNext(i); }
2.123 template<typename I> I& next(I &i) const { return graph->next(i); }
2.124
2.125 template< typename It > It first() const {
2.126 - It e; /*getF*/first(e); return e; }
2.127 + It e; first(e); return e; }
2.128
2.129 template< typename It > It first(const Node& v) const {
2.130 - It e; /*getF*/first(e, v); return e; }
2.131 + It e; first(e, v); return e; }
2.132
2.133 Node head(const Edge& e) const { return graph->tail(e); }
2.134 Node tail(const Edge& e) const { return graph->head(e); }
2.135 @@ -227,20 +302,20 @@
2.136 OutEdgeIt(const Invalid& i) : Edge(i) { }
2.137 OutEdgeIt(const UndirGraphWrapper& _G, const Node& n) : Edge() {
2.138 out_or_in=true;
2.139 - _G.graph->/*getF*/first(out, n);
2.140 + _G.graph->first(out, n);
2.141 if (!(_G.graph->valid(out))) {
2.142 out_or_in=false;
2.143 - _G.graph->/*getF*/first(in, n);
2.144 + _G.graph->first(in, n);
2.145 }
2.146 }
2.147 };
2.148
2.149 - OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const {
2.150 + OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
2.151 e.out_or_in=true;
2.152 - graph->/*getF*/first(e.out, n);
2.153 + graph->first(e.out, n);
2.154 if (!(graph->valid(e.out))) {
2.155 e.out_or_in=false;
2.156 - graph->/*getF*/first(e.in, n);
2.157 + graph->first(e.in, n);
2.158 }
2.159 return e;
2.160 }
2.161 @@ -251,7 +326,7 @@
2.162 graph->next(e.out);
2.163 if (!graph->valid(e.out)) {
2.164 e.out_or_in=false;
2.165 - graph->/*getF*/first(e.in, n);
2.166 + graph->first(e.in, n);
2.167 }
2.168 } else {
2.169 graph->next(e.in);
2.170 @@ -266,19 +341,19 @@
2.171
2.172 typedef OutEdgeIt InEdgeIt;
2.173
2.174 - template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
2.175 -// template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
2.176 -// return graph->/*getF*/first(i, p); }
2.177 + template<typename I> I& first(I& i) const { return graph->first(i); }
2.178 +// template<typename I, typename P> I& first(I& i, const P& p) const {
2.179 +// return graph->first(i, p); }
2.180
2.181 template<typename I> I getNext(const I& i) const {
2.182 return graph->getNext(i); }
2.183 template<typename I> I& next(I &i) const { return graph->next(i); }
2.184
2.185 template< typename It > It first() const {
2.186 - It e; /*getF*/first(e); return e; }
2.187 + It e; first(e); return e; }
2.188
2.189 template< typename It > It first(const Node& v) const {
2.190 - It e; /*getF*/first(e, v); return e; }
2.191 + It e; first(e, v); return e; }
2.192
2.193 Node head(const Edge& e) const { return graph->head(e); }
2.194 Node tail(const Edge& e) const { return graph->tail(e); }
2.195 @@ -348,17 +423,17 @@
2.196 // int nodeNum() const { return graph->nodeNum(); }
2.197 // int edgeNum() const { return graph->edgeNum(); }
2.198
2.199 -// template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
2.200 -// template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
2.201 -// return graph->/*getF*/first(i, p); }
2.202 +// template<typename I> I& first(I& i) const { return graph->first(i); }
2.203 +// template<typename I, typename P> I& first(I& i, const P& p) const {
2.204 +// return graph->first(i, p); }
2.205 // //template<typename I> I next(const I i); { return graph->goNext(i); }
2.206 // //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
2.207
2.208 // template< typename It > It first() const {
2.209 -// It e; /*getF*/first(e); return e; }
2.210 +// It e; first(e); return e; }
2.211
2.212 // template< typename It > It first(Node v) const {
2.213 -// It e; /*getF*/first(e, v); return e; }
2.214 +// It e; first(e, v); return e; }
2.215
2.216 // Node head(const Edge& e) const { return graph->head(e); }
2.217 // Node tail(const Edge& e) const { return graph->tail(e); }
2.218 @@ -455,11 +530,11 @@
2.219 OutEdgeIt(const Invalid& i) : Edge(i) { }
2.220 private:
2.221 OutEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, Node v) : Edge() {
2.222 - resG.graph->/*getF*/first(out, v);
2.223 + resG.graph->first(out, v);
2.224 while( resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
2.225 if (!resG.graph->valid(out)) {
2.226 out_or_in=0;
2.227 - resG.graph->/*getF*/first(in, v);
2.228 + resG.graph->first(in, v);
2.229 while( resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
2.230 }
2.231 }
2.232 @@ -471,7 +546,7 @@
2.233 // while( out.valid() && !(Edge::free()>0) ) { ++out; }
2.234 // if (!out.valid()) {
2.235 // out_or_in=0;
2.236 -// G->/*getF*/first(in, v);
2.237 +// G->first(in, v);
2.238 // while( in.valid() && !(Edge::free()>0) ) { ++in; }
2.239 // }
2.240 // } else {
2.241 @@ -490,22 +565,22 @@
2.242 //EdgeIt(const EdgeIt& e) : Edge(e), v(e.v) { }
2.243 EdgeIt(const Invalid& i) : Edge(i) { }
2.244 EdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG) : Edge() {
2.245 - resG.graph->/*getF*/first(v);
2.246 - if (resG.graph->valid(v)) resG.graph->/*getF*/first(out, v); else out=OldOutEdgeIt(INVALID);
2.247 + resG.graph->first(v);
2.248 + if (resG.graph->valid(v)) resG.graph->first(out, v); else out=OldOutEdgeIt(INVALID);
2.249 while (resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
2.250 while (resG.graph->valid(v) && !resG.graph->valid(out)) {
2.251 resG.graph->next(v);
2.252 - if (resG.graph->valid(v)) resG.graph->/*getF*/first(out, v);
2.253 + if (resG.graph->valid(v)) resG.graph->first(out, v);
2.254 while (resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
2.255 }
2.256 if (!resG.graph->valid(out)) {
2.257 out_or_in=0;
2.258 - resG.graph->/*getF*/first(v);
2.259 - if (resG.graph->valid(v)) resG.graph->/*getF*/first(in, v); else in=OldInEdgeIt(INVALID);
2.260 + resG.graph->first(v);
2.261 + if (resG.graph->valid(v)) resG.graph->first(in, v); else in=OldInEdgeIt(INVALID);
2.262 while (resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
2.263 while (resG.graph->valid(v) && !resG.graph->valid(in)) {
2.264 resG.graph->next(v);
2.265 - if (resG.graph->valid(v)) resG.graph->/*getF*/first(in, v);
2.266 + if (resG.graph->valid(v)) resG.graph->first(in, v);
2.267 while (resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
2.268 }
2.269 }
2.270 @@ -516,17 +591,17 @@
2.271 // while (out.valid() && !(Edge::free()>0) ) { ++out; }
2.272 // while (v.valid() && !out.valid()) {
2.273 // ++v;
2.274 -// if (v.valid()) G->/*getF*/first(out, v);
2.275 +// if (v.valid()) G->first(out, v);
2.276 // while (out.valid() && !(Edge::free()>0) ) { ++out; }
2.277 // }
2.278 // if (!out.valid()) {
2.279 // out_or_in=0;
2.280 -// G->/*getF*/first(v);
2.281 -// if (v.valid()) G->/*getF*/first(in, v); else in=OldInEdgeIt();
2.282 +// G->first(v);
2.283 +// if (v.valid()) G->first(in, v); else in=OldInEdgeIt();
2.284 // while (in.valid() && !(Edge::free()>0) ) { ++in; }
2.285 // while (v.valid() && !in.valid()) {
2.286 // ++v;
2.287 -// if (v.valid()) G->/*getF*/first(in, v);
2.288 +// if (v.valid()) G->first(in, v);
2.289 // while (in.valid() && !(Edge::free()>0) ) { ++in; }
2.290 // }
2.291 // }
2.292 @@ -535,7 +610,7 @@
2.293 // while (in.valid() && !(Edge::free()>0) ) { ++in; }
2.294 // while (v.valid() && !in.valid()) {
2.295 // ++v;
2.296 -// if (v.valid()) G->/*getF*/first(in, v);
2.297 +// if (v.valid()) G->first(in, v);
2.298 // while (in.valid() && !(Edge::free()>0) ) { ++in; }
2.299 // }
2.300 // }
2.301 @@ -543,12 +618,12 @@
2.302 // }
2.303 };
2.304
2.305 - NodeIt& /*getF*/first(NodeIt& v) const { return graph->/*getF*/first(v); }
2.306 - OutEdgeIt& /*getF*/first(OutEdgeIt& e, Node v) const {
2.307 + NodeIt& first(NodeIt& v) const { return graph->first(v); }
2.308 + OutEdgeIt& first(OutEdgeIt& e, Node v) const {
2.309 e=OutEdgeIt(*this, v);
2.310 return e;
2.311 }
2.312 - EdgeIt& /*getF*/first(EdgeIt& e) const {
2.313 + EdgeIt& first(EdgeIt& e) const {
2.314 e=EdgeIt(*this);
2.315 return e;
2.316 }
2.317 @@ -562,7 +637,7 @@
2.318 while( graph->valid(e.out) && !(free(e.out)>0) ) { graph->next(e.out); }
2.319 if (!graph->valid(e.out)) {
2.320 e.out_or_in=0;
2.321 - graph->/*getF*/first(e.in, v);
2.322 + graph->first(e.in, v);
2.323 while( graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
2.324 }
2.325 } else {
2.326 @@ -578,17 +653,17 @@
2.327 while (graph->valid(e.out) && !(free(e.out)>0) ) { graph->next(e.out); }
2.328 while (graph->valid(e.v) && !graph->valid(e.out)) {
2.329 graph->next(e.v);
2.330 - if (graph->valid(e.v)) graph->/*getF*/first(e.out, e.v);
2.331 + if (graph->valid(e.v)) graph->first(e.out, e.v);
2.332 while (graph->valid(e.out) && !(free(e.out)>0) ) { graph->next(e.out); }
2.333 }
2.334 if (!graph->valid(e.out)) {
2.335 e.out_or_in=0;
2.336 - graph->/*getF*/first(e.v);
2.337 - if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v); else e.in=OldInEdgeIt(INVALID);
2.338 + graph->first(e.v);
2.339 + if (graph->valid(e.v)) graph->first(e.in, e.v); else e.in=OldInEdgeIt(INVALID);
2.340 while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
2.341 while (graph->valid(e.v) && !graph->valid(e.in)) {
2.342 graph->next(e.v);
2.343 - if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v);
2.344 + if (graph->valid(e.v)) graph->first(e.in, e.v);
2.345 while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
2.346 }
2.347 }
2.348 @@ -597,7 +672,7 @@
2.349 while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
2.350 while (graph->valid(e.v) && !graph->valid(e.in)) {
2.351 graph->next(e.v);
2.352 - if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v);
2.353 + if (graph->valid(e.v)) graph->first(e.in, e.v);
2.354 while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
2.355 }
2.356 }
2.357 @@ -608,14 +683,14 @@
2.358 template< typename It >
2.359 It first() const {
2.360 It e;
2.361 - /*getF*/first(e);
2.362 + first(e);
2.363 return e;
2.364 }
2.365
2.366 template< typename It >
2.367 It first(Node v) const {
2.368 It e;
2.369 - /*getF*/first(e, v);
2.370 + first(e, v);
2.371 return e;
2.372 }
2.373
2.374 @@ -708,7 +783,7 @@
2.375 first_out_edges(*this) /*, dist(*this)*/ {
2.376 for(NodeIt n=this->template first<NodeIt>(); this->valid(n); this->next(n)) {
2.377 OutEdgeIt e;
2.378 - ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(e, n);
2.379 + ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(e, n);
2.380 first_out_edges.set(n, e);
2.381 }
2.382 }
2.383 @@ -739,28 +814,28 @@
2.384 //typedef typename Graph::SymEdgeIt SymEdgeIt;
2.385 //typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeIt EdgeIt;
2.386
2.387 - NodeIt& /*getF*/first(NodeIt& n) const {
2.388 - return ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(n);
2.389 + NodeIt& first(NodeIt& n) const {
2.390 + return ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(n);
2.391 }
2.392
2.393 - OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const {
2.394 + OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
2.395 e=first_out_edges.get(n);
2.396 return e;
2.397 }
2.398
2.399 - //ROSSZ template<typename I> I& /*getF*/first(I& i) const { return /*getF*/first(i); }
2.400 - //ROSSZ template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
2.401 - // return /*getF*/first(i, p); }
2.402 + //ROSSZ template<typename I> I& first(I& i) const { return first(i); }
2.403 + //ROSSZ template<typename I, typename P> I& first(I& i, const P& p) const {
2.404 + // return first(i, p); }
2.405
2.406 //template<typename I> I getNext(const I& i) const {
2.407 // return graph->getNext(i); }
2.408 //template<typename I> I& next(I &i) const { return graph->next(i); }
2.409
2.410 template< typename It > It first() const {
2.411 - It e; /*getF*/first(e); return e; }
2.412 + It e; first(e); return e; }
2.413
2.414 template< typename It > It first(const Node& v) const {
2.415 - It e; /*getF*/first(e, v); return e; }
2.416 + It e; first(e, v); return e; }
2.417
2.418 //Node head(const Edge& e) const { return graph->head(e); }
2.419 //Node tail(const Edge& e) const { return graph->tail(e); }
2.420 @@ -838,8 +913,8 @@
2.421 ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>(_G, _flow, _capacity), dist(*this, graph->nodeNum()) {
2.422 }
2.423
2.424 - OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const {
2.425 - ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(e, n);
2.426 + OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
2.427 + ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(e, n);
2.428 while (valid(e) && (dist.get(tail(e))/*+1!=*/>=dist.get(head(e))))
2.429 ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
2.430 return e;
2.431 @@ -856,8 +931,8 @@
2.432 return e;
2.433 }
2.434
2.435 - NodeIt& /*getF*/first(NodeIt& n) const {
2.436 - return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(n);
2.437 + NodeIt& first(NodeIt& n) const {
2.438 + return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(n);
2.439 }
2.440
2.441 void erase(const Edge& e) {
2.442 @@ -874,19 +949,19 @@
2.443 //void setGraph(Graph& _graph) { graph = &_graph; }
2.444 //Graph& getGraph() const { return (*graph); }
2.445
2.446 - //template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
2.447 - //template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const {
2.448 - // return graph->/*getF*/first(i, p); }
2.449 + //template<typename I> I& first(I& i) const { return graph->first(i); }
2.450 + //template<typename I, typename P> I& first(I& i, const P& p) const {
2.451 + // return graph->first(i, p); }
2.452
2.453 //template<typename I> I getNext(const I& i) const {
2.454 // return graph->getNext(i); }
2.455 //template<typename I> I& next(I &i) const { return graph->next(i); }
2.456
2.457 template< typename It > It first() const {
2.458 - It e; /*getF*/first(e); return e; }
2.459 + It e; first(e); return e; }
2.460
2.461 template< typename It > It first(const Node& v) const {
2.462 - It e; /*getF*/first(e, v); return e; }
2.463 + It e; first(e, v); return e; }
2.464
2.465 //Node head(const Edge& e) const { return graph->head(e); }
2.466 //Node tail(const Edge& e) const { return graph->tail(e); }
2.467 @@ -970,20 +1045,20 @@
2.468 // int nodeNum() const { return graph->nodeNum(); }
2.469 // int edgeNum() const { return graph->edgeNum(); }
2.470
2.471 -// Node& /*getF*/first(Node& n) const { return graph->/*getF*/first(n); }
2.472 +// Node& first(Node& n) const { return graph->first(n); }
2.473
2.474 // // Edge and SymEdge is missing!!!!
2.475 // // Edge <-> In/OutEdgeIt conversion is missing!!!!
2.476
2.477 // //FIXME
2.478 -// OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const
2.479 +// OutEdgeIt& first(OutEdgeIt& e, const Node& n) const
2.480 // {
2.481 // e.n=n;
2.482 -// graph->/*getF*/first(e.o,n);
2.483 +// graph->first(e.o,n);
2.484 // while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
2.485 // graph->goNext(e.o);
2.486 // if(!graph->valid(e.o)) {
2.487 -// graph->/*getF*/first(e.i,n);
2.488 +// graph->first(e.i,n);
2.489 // while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
2.490 // graph->goNext(e.i);
2.491 // }
2.492 @@ -996,7 +1071,7 @@
2.493 // while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
2.494 // graph->goNext(e.o);
2.495 // if(graph->valid(e.o)) return e;
2.496 -// else graph->/*getF*/first(e.i,e.n);
2.497 +// else graph->first(e.i,e.n);
2.498 // }
2.499 // else {
2.500 // while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
2.501 @@ -1009,14 +1084,14 @@
2.502 // //bool valid(const OutEdgeIt e) { return graph->valid(e.o)||graph->valid(e.i);}
2.503
2.504 // //FIXME
2.505 -// InEdgeIt& /*getF*/first(InEdgeIt& e, const Node& n) const
2.506 +// InEdgeIt& first(InEdgeIt& e, const Node& n) const
2.507 // {
2.508 // e.n=n;
2.509 -// graph->/*getF*/first(e.i,n);
2.510 +// graph->first(e.i,n);
2.511 // while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
2.512 // graph->goNext(e.i);
2.513 // if(!graph->valid(e.i)) {
2.514 -// graph->/*getF*/first(e.o,n);
2.515 +// graph->first(e.o,n);
2.516 // while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
2.517 // graph->goNext(e.o);
2.518 // }
2.519 @@ -1029,7 +1104,7 @@
2.520 // while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
2.521 // graph->goNext(e.i);
2.522 // if(graph->valid(e.i)) return e;
2.523 -// else graph->/*getF*/first(e.o,e.n);
2.524 +// else graph->first(e.o,e.n);
2.525 // }
2.526 // else {
2.527 // while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
2.528 @@ -1045,10 +1120,10 @@
2.529 // //template<typename I> I next(const I i); { return graph->goNext(i); }
2.530
2.531 // template< typename It > It first() const {
2.532 -// It e; /*getF*/first(e); return e; }
2.533 +// It e; first(e); return e; }
2.534
2.535 // template< typename It > It first(Node v) const {
2.536 -// It e; /*getF*/first(e, v); return e; }
2.537 +// It e; first(e, v); return e; }
2.538
2.539 // Node head(const Edge& e) const { return graph->head(e); }
2.540 // Node tail(const Edge& e) const { return graph->tail(e); }