lemon-0.x: src/work/marci/graph_wrapper.h@6e6db1c49bc1 (annotated)

marci@174	1	// -- c++ --
marci@259	2	#ifndef HUGO_GRAPH_WRAPPER_H
marci@259	3	#define HUGO_GRAPH_WRAPPER_H
marci@76	4
marci@174	5	#include <invalid.h>
marci@174	6
alpar@105	7	namespace hugo {
marci@76	8
marci@303	9	template<typename Graph>
marci@303	10	class GraphWrapper {
marci@212	11	protected:
marci@303	12	Graph* graph;
marci@212	13
marci@212	14	public:
marci@311	15	typedef Graph BaseGraph;
marci@303	16	typedef Graph ParentGraph;
marci@212	17
marci@303	18	// GraphWrapper() : graph(0) { }
marci@303	19	GraphWrapper(Graph& _graph) : graph(&_graph) { }
marci@303	20	// void setGraph(Graph& _graph) { graph=&_graph; }
marci@303	21	// Graph& getGraph() const { return *graph; }
marci@303	22
marci@317	23	// typedef typename Graph::Node Node;
marci@317	24	class Node : public Graph::Node {
marci@317	25	friend class GraphWrapper<Graph>;
marci@265	26	public:
marci@317	27	Node() { }
marci@317	28	Node(const typename Graph::Node& _n) : Graph::Node(_n) { }
marci@317	29	Node(const Invalid& i) : Graph::Node(i) { }
marci@317	30	};
marci@317	31	class NodeIt {
marci@317	32	friend class GraphWrapper<Graph>;
marci@317	33	typename Graph::NodeIt n;
marci@317	34	public:
marci@265	35	NodeIt() { }
marci@317	36	NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }
marci@317	37	NodeIt(const Invalid& i) : n(i) { }
marci@317	38	NodeIt(const GraphWrapper<Graph>& _G) : n(*(_G.graph)) { }
marci@317	39	operator Node() const { return Node(typename Graph::Node(n)); }
marci@265	40	};
marci@317	41	// class Node : public Graph::Node {
marci@317	42	// public:
marci@317	43	// Node() { }
marci@317	44	// Node(const typename Graph::Node& n) : Graph::Node(n) { }
marci@317	45	// Node(const Invalid& i) : Graph::Node(i) { }
marci@317	46	// };
marci@317	47	// class NodeIt : public Graph::NodeIt {
marci@317	48	// typedef typename Graph::NodeIt GraphNodeIt;
marci@317	49	// public:
marci@317	50	// NodeIt() { }
marci@317	51	// NodeIt(const typename Graph::NodeIt& n) : Graph::NodeIt(n) { }
marci@317	52	// NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
marci@317	53	// NodeIt(const GraphWrapper<Graph>& _G) :
marci@317	54	// Graph::NodeIt(*(_G.graph)) { }
marci@317	55	// operator Node() const {
marci@317	56	// return Node(typename Graph::Node(
marci@317	57	// static_cast<typename Graph::NodeIt>(*this)
marci@317	58	// ));
marci@317	59	// }
marci@317	60	// };
marci@317	61	// typedef typename Graph::Edge Edge;
marci@317	62	class Edge : public Graph::Edge {
marci@317	63	friend class GraphWrapper<Graph>;
marci@317	64	public:
marci@317	65	Edge() { }
marci@317	66	Edge(const typename Graph::Edge& _e) : Graph::Edge(_e) { }
marci@317	67	Edge(const Invalid& i) : Graph::Edge(i) { }
marci@317	68	};
marci@317	69	class OutEdgeIt {
marci@317	70	friend class GraphWrapper<Graph>;
marci@317	71	// typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
marci@317	72	typename Graph::OutEdgeIt e;
marci@265	73	public:
marci@265	74	OutEdgeIt() { }
marci@317	75	OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }
marci@317	76	OutEdgeIt(const Invalid& i) : e(i) { }
marci@317	77	OutEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) :
marci@317	78	e(*(_G.graph), typename Graph::Node(_n)) { }
marci@317	79	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@265	80	};
marci@317	81	class InEdgeIt {
marci@317	82	friend class GraphWrapper<Graph>;
marci@317	83	// typedef typename Graph::InEdgeIt GraphInEdgeIt;
marci@317	84	typename Graph::InEdgeIt e;
marci@265	85	public:
marci@265	86	InEdgeIt() { }
marci@317	87	InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
marci@317	88	InEdgeIt(const Invalid& i) : e(i) { }
marci@317	89	InEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) :
marci@317	90	e(*(_G.graph), typename Graph::Node(_n)) { }
marci@317	91	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@265	92	};
marci@303	93	//typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@317	94	class EdgeIt {
marci@317	95	friend class GraphWrapper<Graph>;
marci@317	96	// typedef typename Graph::EdgeIt GraphEdgeIt;
marci@317	97	typename Graph::EdgeIt e;
marci@265	98	public:
marci@265	99	EdgeIt() { }
marci@317	100	EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
marci@317	101	EdgeIt(const Invalid& i) : e(i) { }
marci@317	102	EdgeIt(const GraphWrapper<Graph>& _G) : e(*(_G.graph)) { }
marci@317	103	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@265	104	};
marci@303	105
marci@303	106	NodeIt& first(NodeIt& i) const {
marci@317	107	i=NodeIt(*this); return i;
marci@265	108	}
marci@303	109	OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
marci@317	110	i=OutEdgeIt(*this, p); return i;
marci@303	111	}
marci@303	112	InEdgeIt& first(InEdgeIt& i, const Node& p) const {
marci@317	113	i=InEdgeIt(*this, p); return i;
marci@303	114	}
marci@311	115	EdgeIt& first(EdgeIt& i) const {
marci@317	116	i=EdgeIt(*this); return i;
marci@311	117	}
marci@312	118	// template<typename I> I& first(I& i) const {
marci@312	119	// i=I(*this);
marci@312	120	// return i;
marci@312	121	// }
marci@303	122	// template<typename I, typename P> I& first(I& i, const P& p) const {
marci@303	123	// i=I(*this, p);
marci@303	124	// return i;
marci@303	125	// }
marci@212	126
marci@303	127	// template<typename I> I getNext(const I& i) const {
marci@303	128	// return gw.getNext(i); }
marci@312	129
marci@317	130	NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
marci@317	131	OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i.e); return i; }
marci@317	132	InEdgeIt& next(InEdgeIt& i) const { graph->next(i.e); return i; }
marci@317	133	EdgeIt& next(EdgeIt& i) const { graph->next(i.e); return i; }
marci@312	134	// template<typename I> I& next(I &i) const { graph->next(i); return i; }
marci@212	135	template< typename It > It first() const {
marci@212	136	It e; this->first(e); return e; }
marci@212	137
marci@212	138	template< typename It > It first(const Node& v) const {
marci@212	139	It e; this->first(e, v); return e; }
marci@212	140
marci@317	141	Node head(const Edge& e) const {
marci@317	142	return Node(graph->head(static_cast<typename Graph::Edge>(e))); }
marci@317	143	Node tail(const Edge& e) const {
marci@317	144	return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
marci@312	145	// Node tail(const OutEdgeIt& e) const { return graph->tail(Edge(e)); }
marci@212	146
marci@317	147	bool valid(const Node& n) const {
marci@317	148	return graph->valid(static_cast<typename Graph::Node>(n)); }
marci@317	149	bool valid(const Edge& e) const {
marci@317	150	return graph->valid(static_cast<typename Graph::Edge>(e)); }
marci@317	151	// template<typename I> bool valid(const I& i) const {
marci@317	152	// return graph->valid(i); }
marci@212	153
marci@212	154	//template<typename I> void setInvalid(const I &i);
marci@212	155	//{ return graph->setInvalid(i); }
marci@212	156
marci@303	157	int nodeNum() const { return graph->nodeNum(); }
marci@303	158	int edgeNum() const { return graph->edgeNum(); }
marci@212	159
marci@317	160	Node aNode(const OutEdgeIt& e) const { return Node(graph->aNode(e.e)); }
marci@317	161	Node aNode(const InEdgeIt& e) const { return Node(graph->aNode(e.e)); }
marci@317	162	Node bNode(const OutEdgeIt& e) const { return Node(graph->bNode(e.e)); }
marci@317	163	Node bNode(const InEdgeIt& e) const { return Node(graph->bNode(e.e)); }
marci@317	164	// template<typename I> Node aNode(const I& e) const {
marci@317	165	// return Node(graph->aNode(e.e)); }
marci@317	166	// template<typename I> Node bNode(const I& e) const {
marci@317	167	// return Node(graph->bNode(e.e)); }
marci@212	168
marci@317	169	Node addNode() const { return Node(graph->addNode()); }
marci@212	170	Edge addEdge(const Node& tail, const Node& head) const {
marci@317	171	return Edge(graph->addEdge(tail, head)); }
marci@317	172
marci@317	173	void erase(const Node& i) const { graph->erase(i); }
marci@317	174	void erase(const Edge& i) const { graph->erase(i); }
marci@317	175	// template<typename I> void erase(const I& i) const { graph->erase(i); }
marci@212	176
marci@303	177	void clear() const { graph->clear(); }
marci@212	178
marci@303	179	template<typename T> class NodeMap : public Graph::NodeMap<T> {
marci@212	180	public:
marci@303	181	NodeMap(const GraphWrapper<Graph>& _G) :
marci@303	182	Graph::NodeMap<T>(*(_G.graph)) { }
marci@303	183	NodeMap(const GraphWrapper<Graph>& _G, T a) :
marci@303	184	Graph::NodeMap<T>(*(_G.graph), a) { }
marci@317	185	// T operator[](const Node& n) const {
marci@317	186	// return Graph::NodeMap<T>::operator[](n);
marci@317	187	// }
marci@212	188	};
marci@212	189
marci@303	190	template<typename T> class EdgeMap : public Graph::EdgeMap<T> {
marci@212	191	public:
marci@303	192	EdgeMap(const GraphWrapper<Graph>& _G) :
marci@303	193	Graph::EdgeMap<T>(*(_G.graph)) { }
marci@303	194	EdgeMap(const GraphWrapper<Graph>& _G, T a) :
marci@303	195	Graph::EdgeMap<T>(*(_G.graph), a) { }
marci@212	196	};
marci@212	197	};
marci@212	198
marci@303	199
marci@230	200	// template<typename Graph>
marci@230	201	// class RevGraphWrapper
marci@230	202	// {
marci@230	203	// protected:
marci@230	204	// Graph* graph;
marci@230	205
marci@230	206	// public:
marci@303	207	// typedef Graph ParentGraph;
marci@230	208
marci@230	209	// typedef typename Graph::Node Node;
marci@230	210	// typedef typename Graph::NodeIt NodeIt;
marci@230	211
marci@230	212	// typedef typename Graph::Edge Edge;
marci@230	213	// typedef typename Graph::OutEdgeIt InEdgeIt;
marci@230	214	// typedef typename Graph::InEdgeIt OutEdgeIt;
marci@230	215	// //typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@230	216	// typedef typename Graph::EdgeIt EdgeIt;
marci@230	217
marci@230	218	// //RevGraphWrapper() : graph(0) { }
marci@230	219	// RevGraphWrapper(Graph& _graph) : graph(&_graph) { }
marci@230	220
marci@230	221	// void setGraph(Graph& _graph) { graph = &_graph; }
marci@230	222	// Graph& getGraph() const { return (*graph); }
marci@230	223
marci@230	224	// template<typename I> I& first(I& i) const { return graph->first(i); }
marci@230	225	// template<typename I, typename P> I& first(I& i, const P& p) const {
marci@230	226	// return graph->first(i, p); }
marci@230	227
marci@230	228	// template<typename I> I getNext(const I& i) const {
marci@230	229	// return graph->getNext(i); }
marci@230	230	// template<typename I> I& next(I &i) const { return graph->next(i); }
marci@230	231
marci@230	232	// template< typename It > It first() const {
marci@230	233	// It e; first(e); return e; }
marci@230	234
marci@230	235	// template< typename It > It first(const Node& v) const {
marci@230	236	// It e; first(e, v); return e; }
marci@230	237
marci@230	238	// Node head(const Edge& e) const { return graph->tail(e); }
marci@230	239	// Node tail(const Edge& e) const { return graph->head(e); }
marci@230	240
marci@230	241	// template<typename I> bool valid(const I& i) const
marci@230	242	// { return graph->valid(i); }
marci@230	243
marci@230	244	// //template<typename I> void setInvalid(const I &i);
marci@230	245	// //{ return graph->setInvalid(i); }
marci@230	246
marci@230	247	// template<typename I> Node aNode(const I& e) const {
marci@230	248	// return graph->aNode(e); }
marci@230	249	// template<typename I> Node bNode(const I& e) const {
marci@230	250	// return graph->bNode(e); }
marci@230	251
marci@230	252	// Node addNode() const { return graph->addNode(); }
marci@230	253	// Edge addEdge(const Node& tail, const Node& head) const {
marci@230	254	// return graph->addEdge(tail, head); }
marci@230	255
marci@230	256	// int nodeNum() const { return graph->nodeNum(); }
marci@230	257	// int edgeNum() const { return graph->edgeNum(); }
marci@230	258
marci@230	259	// template<typename I> void erase(const I& i) const { graph->erase(i); }
marci@230	260
marci@230	261	// void clear() const { graph->clear(); }
marci@230	262
marci@230	263	// template<typename T> class NodeMap : public Graph::NodeMap<T> {
marci@230	264	// public:
marci@230	265	// NodeMap(const RevGraphWrapper<Graph>& _G) :
marci@230	266	// Graph::NodeMap<T>(_G.getGraph()) { }
marci@230	267	// NodeMap(const RevGraphWrapper<Graph>& _G, T a) :
marci@230	268	// Graph::NodeMap<T>(_G.getGraph(), a) { }
marci@230	269	// };
marci@230	270
marci@230	271	// template<typename T> class EdgeMap : public Graph::EdgeMap<T> {
marci@230	272	// public:
marci@230	273	// EdgeMap(const RevGraphWrapper<Graph>& _G) :
marci@230	274	// Graph::EdgeMap<T>(_G.getGraph()) { }
marci@230	275	// EdgeMap(const RevGraphWrapper<Graph>& _G, T a) :
marci@230	276	// Graph::EdgeMap<T>(_G.getGraph(), a) { }
marci@230	277	// };
marci@230	278	// };
marci@230	279
marci@235	280
marci@303	281	template<typename Graph>
marci@303	282	class RevGraphWrapper : public GraphWrapper<Graph> {
marci@230	283	public:
marci@303	284	typedef typename GraphWrapper<Graph>::Node Node;
marci@303	285	typedef typename GraphWrapper<Graph>::Edge Edge;
marci@279	286	//FIXME
marci@303	287	//If Graph::OutEdgeIt is not defined
marci@279	288	//and we do not want to use RevGraphWrapper::InEdgeIt,
marci@279	289	//this won't work, because of typedef
marci@279	290	//OR
marci@279	291	//graphs have to define their non-existing iterators to void
marci@279	292	//Unfortunately all the typedefs are instantiated in templates,
marci@279	293	//unlike other stuff
marci@303	294	typedef typename GraphWrapper<Graph>::OutEdgeIt InEdgeIt;
marci@303	295	typedef typename GraphWrapper<Graph>::InEdgeIt OutEdgeIt;
marci@237	296
marci@303	297	// RevGraphWrapper() : GraphWrapper<Graph>() { }
marci@303	298	RevGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { }
marci@238	299
marci@237	300	Node head(const Edge& e) const
marci@303	301	{ return GraphWrapper<Graph>::tail(e); }
marci@237	302	Node tail(const Edge& e) const
marci@303	303	{ return GraphWrapper<Graph>::head(e); }
marci@76	304	};
marci@76	305
marci@263	306	//Subgraph on the same node-set and partial edge-set
marci@311	307	template<typename Graph, typename NodeFilterMap,
marci@311	308	typename EdgeFilterMap>
marci@303	309	class SubGraphWrapper : public GraphWrapper<Graph> {
marci@263	310	protected:
marci@311	311	NodeFilterMap* node_filter_map;
marci@311	312	EdgeFilterMap* edge_filter_map;
marci@263	313	public:
marci@311	314	// SubGraphWrapper() : GraphWrapper<Graph>(), filter_map(0) { }
marci@311	315	SubGraphWrapper(Graph& _graph, NodeFilterMap& _node_filter_map,
marci@311	316	EdgeFilterMap& _edge_filter_map) :
marci@311	317	GraphWrapper<Graph>(_graph), node_filter_map(&_node_filter_map),
marci@311	318	edge_filter_map(&_edge_filter_map) { }
marci@263	319
marci@317	320	typedef typename GraphWrapper<Graph>::Node Node;
marci@317	321	class NodeIt {
marci@317	322	friend class GraphWrapper<Graph>;
marci@317	323	friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;
marci@317	324	typename Graph::NodeIt n;
marci@317	325	public:
marci@311	326	NodeIt() { }
marci@317	327	NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }
marci@317	328	NodeIt(const Invalid& i) : n(i) { }
marci@311	329	NodeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :
marci@317	330	n(*(_G.graph)) {
marci@317	331	while (_G.graph->valid(n) && !(*(_G.node_filter_map))[n])
marci@317	332	_G.graph->next(n);
marci@311	333	}
marci@317	334	operator Node() const { return Node(typename Graph::Node(n)); }
marci@311	335	};
marci@317	336	// class NodeIt : public Graph::NodeIt {
marci@317	337	// // typedef typename Graph::NodeIt GraphNodeIt;
marci@317	338	// public:
marci@317	339	// NodeIt() { }
marci@317	340	// NodeIt(const typename Graph::NodeIt& n) : Graph::NodeIt(n) { }
marci@317	341	// NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
marci@317	342	// NodeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :
marci@317	343	// Graph::NodeIt(*(_G.graph)) {
marci@317	344	// while (_G.graph->valid((this)/.GraphNodeIt*/) &&
marci@317	345	// !((_G.node_filter_map))[(this)/.GraphNodeIt/])
marci@317	346	// _G.graph->next((this)/.GraphNodeIt*/);
marci@317	347	// }
marci@317	348	// };
marci@317	349	typedef typename GraphWrapper<Graph>::Edge Edge;
marci@317	350	class OutEdgeIt {
marci@317	351	friend class GraphWrapper<Graph>;
marci@317	352	friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;
marci@311	353	// typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
marci@317	354	typename Graph::OutEdgeIt e;
marci@311	355	public:
marci@311	356	OutEdgeIt() { }
marci@317	357	OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }
marci@317	358	OutEdgeIt(const Invalid& i) : e(i) { }
marci@317	359	OutEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G,
marci@317	360	const Node& _n) :
marci@317	361	e(*(_G.graph), typename Graph::Node(_n)) {
marci@317	362	while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])
marci@317	363	_G.graph->next(e);
marci@311	364	}
marci@317	365	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@311	366	};
marci@317	367	class InEdgeIt {
marci@317	368	friend class GraphWrapper<Graph>;
marci@317	369	friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;
marci@311	370	// typedef typename Graph::InEdgeIt GraphInEdgeIt;
marci@317	371	typename Graph::InEdgeIt e;
marci@311	372	public:
marci@311	373	InEdgeIt() { }
marci@317	374	InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
marci@317	375	InEdgeIt(const Invalid& i) : e(i) { }
marci@311	376	InEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G,
marci@317	377	const Node& _n) :
marci@317	378	e(*(_G.graph), typename Graph::Node(_n)) {
marci@317	379	while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])
marci@317	380	_G.graph->next(e);
marci@311	381	}
marci@317	382	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@311	383	};
marci@317	384	//typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@317	385	class EdgeIt {
marci@317	386	friend class GraphWrapper<Graph>;
marci@317	387	friend class SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>;
marci@311	388	// typedef typename Graph::EdgeIt GraphEdgeIt;
marci@317	389	typename Graph::EdgeIt e;
marci@311	390	public:
marci@311	391	EdgeIt() { }
marci@317	392	EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
marci@317	393	EdgeIt(const Invalid& i) : e(i) { }
marci@311	394	EdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :
marci@317	395	e(*(_G.graph)) {
marci@317	396	while (_G.graph->valid(e) && !(*(_G.edge_filter_map))[e])
marci@317	397	_G.graph->next(e);
marci@311	398	}
marci@317	399	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@311	400	};
marci@317	401	// operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@317	402	// };
marci@317	403	// class OutEdgeIt : public Graph::OutEdgeIt {
marci@317	404	// // typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
marci@317	405	// public:
marci@317	406	// OutEdgeIt() { }
marci@317	407	// OutEdgeIt(const typename Graph::OutEdgeIt& e) : Graph::OutEdgeIt(e) { }
marci@317	408	// OutEdgeIt(const Invalid& i) : Graph::OutEdgeIt(i) { }
marci@317	409	// OutEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>&
marci@317	410	// _G, const Node& n) :
marci@317	411	// Graph::OutEdgeIt(*(_G.graph), n) {
marci@317	412	// while (_G.graph->valid((this)/.GraphOutEdgeIt*/) &&
marci@317	413	// !((_G.edge_filter_map))[(this)/.GraphOutEdgeIt/])
marci@317	414	// _G.graph->next((this)/.GraphOutEdgeIt*/);
marci@317	415	// }
marci@317	416	// };
marci@317	417	// class InEdgeIt : public Graph::InEdgeIt {
marci@317	418	// // typedef typename Graph::InEdgeIt GraphInEdgeIt;
marci@317	419	// public:
marci@317	420	// InEdgeIt() { }
marci@317	421	// InEdgeIt(const typename Graph::InEdgeIt& e) : Graph::InEdgeIt(e) { }
marci@317	422	// InEdgeIt(const Invalid& i) : Graph::InEdgeIt(i) { }
marci@317	423	// InEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G,
marci@317	424	// const Node& n) :
marci@317	425	// Graph::InEdgeIt(*(_G.graph), n) {
marci@317	426	// while (_G.graph->valid((this)/.GraphInEdgeIt*/) &&
marci@317	427	// !((_G.edge_filter_map))[(this)/.GraphInEdgeIt/])
marci@317	428	// _G.graph->next((this)/.GraphInEdgeIt*/);
marci@317	429	// }
marci@317	430	// };
marci@317	431	// // //typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@317	432	// class EdgeIt : public Graph::EdgeIt {
marci@317	433	// // typedef typename Graph::EdgeIt GraphEdgeIt;
marci@317	434	// public:
marci@317	435	// EdgeIt() { }
marci@317	436	// EdgeIt(const typename Graph::EdgeIt& e) : Graph::EdgeIt(e) { }
marci@317	437	// EdgeIt(const Invalid& i) : Graph::EdgeIt(i) { }
marci@317	438	// EdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :
marci@317	439	// Graph::EdgeIt(*(_G.graph)) {
marci@317	440	// while (_G.graph->valid((this)/.GraphEdgeIt*/) &&
marci@317	441	// !((_G.edge_filter_map))[(this)/.GraphEdgeIt/])
marci@317	442	// _G.graph->next((this)/.GraphEdgeIt*/);
marci@317	443	// }
marci@317	444	// };
marci@311	445
marci@317	446
marci@317	447	NodeIt& first(NodeIt& i) const {
marci@317	448	i=NodeIt(*this); return i;
marci@263	449	}
marci@317	450	OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
marci@317	451	i=OutEdgeIt(*this, p); return i;
marci@311	452	}
marci@317	453	InEdgeIt& first(InEdgeIt& i, const Node& p) const {
marci@317	454	i=InEdgeIt(*this, p); return i;
marci@311	455	}
marci@317	456	EdgeIt& first(EdgeIt& i) const {
marci@317	457	i=EdgeIt(*this); return i;
marci@263	458	}
marci@263	459
marci@311	460	// template<typename I> I& first(I& i) const {
marci@311	461	// graph->first(i);
marci@311	462	// //while (graph->valid(i) && !filter_map->get(i)) { graph->next(i); }
marci@311	463	// while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@311	464	// return i;
marci@311	465	// }
marci@311	466	// template<typename I, typename P> I& first(I& i, const P& p) const {
marci@311	467	// graph->first(i, p);
marci@311	468	// // while (graph->valid(i) && !filter_map->get(i)) { graph->next(i); }
marci@311	469	// while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@311	470	// return i;
marci@311	471	// }
marci@311	472
marci@311	473	NodeIt& next(NodeIt& i) const {
marci@317	474	graph->next(i.n);
marci@317	475	while (graph->valid(i) && !(*node_filter_map)[i.n]) { graph->next(i.n); }
marci@311	476	return i;
marci@311	477	}
marci@311	478	OutEdgeIt& next(OutEdgeIt& i) const {
marci@317	479	graph->next(i.e);
marci@317	480	while (graph->valid(i) && !(*edge_filter_map)[i.e]) { graph->next(i.e); }
marci@311	481	return i;
marci@311	482	}
marci@311	483	InEdgeIt& next(InEdgeIt& i) const {
marci@317	484	graph->next(i.e);
marci@317	485	while (graph->valid(i) && !(*edge_filter_map)[i.e]) { graph->next(i.e); }
marci@311	486	return i;
marci@311	487	}
marci@311	488	EdgeIt& next(EdgeIt& i) const {
marci@317	489	graph->next(i.e);
marci@317	490	while (graph->valid(i) && !(*edge_filter_map)[i.e]) { graph->next(i.e); }
marci@311	491	return i;
marci@311	492	}
marci@311	493
marci@317	494
marci@317	495	Node aNode(const OutEdgeIt& e) const { return Node(graph->aNode(e.e)); }
marci@317	496	Node aNode(const InEdgeIt& e) const { return Node(graph->aNode(e.e)); }
marci@317	497	Node bNode(const OutEdgeIt& e) const { return Node(graph->bNode(e.e)); }
marci@317	498	Node bNode(const InEdgeIt& e) const { return Node(graph->bNode(e.e)); }
marci@317	499
marci@263	500	//template<typename I> I getNext(const I& i) const {
marci@263	501	// return gw.getNext(i);
marci@263	502	//}
marci@311	503	// template<typename I> I& next(I &i) const {
marci@311	504	// graph->next(i);
marci@311	505	// // while (graph->valid(i) && !filter_map-get(i)) { graph->next(i); }
marci@311	506	// while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@311	507	// return i;
marci@311	508	// }
marci@263	509
marci@263	510	template< typename It > It first() const {
marci@263	511	It e; this->first(e); return e; }
marci@263	512
marci@263	513	template< typename It > It first(const Node& v) const {
marci@263	514	It e; this->first(e, v); return e; }
marci@263	515	};
marci@155	516
marci@317	517	// //Subgraph on the same node-set and partial edge-set
marci@317	518	// template<typename Graph, typename NodeFilterMap,
marci@317	519	// typename EdgeFilterMap>
marci@317	520	// class SubGraphWrapper : public GraphWrapper<Graph> {
marci@317	521	// protected:
marci@317	522	// NodeFilterMap* node_filter_map;
marci@317	523	// EdgeFilterMap* edge_filter_map;
marci@317	524	// public:
marci@317	525	// // SubGraphWrapper() : GraphWrapper<Graph>(), filter_map(0) { }
marci@317	526	// SubGraphWrapper(Graph& _graph, NodeFilterMap& _node_filter_map,
marci@317	527	// EdgeFilterMap& _edge_filter_map) :
marci@317	528	// GraphWrapper<Graph>(_graph), node_filter_map(&_node_filter_map),
marci@317	529	// edge_filter_map(&_edge_filter_map) { }
marci@317	530
marci@317	531
marci@317	532	// typedef typename Graph::Node Node;
marci@317	533	// class NodeIt : public Graph::NodeIt {
marci@317	534	// // typedef typename Graph::NodeIt GraphNodeIt;
marci@317	535	// public:
marci@317	536	// NodeIt() { }
marci@317	537	// NodeIt(const typename Graph::NodeIt& n) : Graph::NodeIt(n) { }
marci@317	538	// NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
marci@317	539	// NodeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :
marci@317	540	// Graph::NodeIt(*(_G.graph)) {
marci@317	541	// while (_G.graph->valid((this)/.GraphNodeIt*/) &&
marci@317	542	// !((_G.node_filter_map))[(this)/.GraphNodeIt/])
marci@317	543	// _G.graph->next((this)/.GraphNodeIt*/);
marci@317	544	// }
marci@317	545	// };
marci@317	546	// typedef typename Graph::Edge Edge;
marci@317	547	// class OutEdgeIt : public Graph::OutEdgeIt {
marci@317	548	// // typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
marci@317	549	// public:
marci@317	550	// OutEdgeIt() { }
marci@317	551	// OutEdgeIt(const typename Graph::OutEdgeIt& e) : Graph::OutEdgeIt(e) { }
marci@317	552	// OutEdgeIt(const Invalid& i) : Graph::OutEdgeIt(i) { }
marci@317	553	// OutEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>&
marci@317	554	// _G, const Node& n) :
marci@317	555	// Graph::OutEdgeIt(*(_G.graph), n) {
marci@317	556	// while (_G.graph->valid((this)/.GraphOutEdgeIt*/) &&
marci@317	557	// !((_G.edge_filter_map))[(this)/.GraphOutEdgeIt/])
marci@317	558	// _G.graph->next((this)/.GraphOutEdgeIt*/);
marci@317	559	// }
marci@317	560	// };
marci@317	561	// class InEdgeIt : public Graph::InEdgeIt {
marci@317	562	// // typedef typename Graph::InEdgeIt GraphInEdgeIt;
marci@317	563	// public:
marci@317	564	// InEdgeIt() { }
marci@317	565	// InEdgeIt(const typename Graph::InEdgeIt& e) : Graph::InEdgeIt(e) { }
marci@317	566	// InEdgeIt(const Invalid& i) : Graph::InEdgeIt(i) { }
marci@317	567	// InEdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G,
marci@317	568	// const Node& n) :
marci@317	569	// Graph::InEdgeIt(*(_G.graph), n) {
marci@317	570	// while (_G.graph->valid((this)/.GraphInEdgeIt*/) &&
marci@317	571	// !((_G.edge_filter_map))[(this)/.GraphInEdgeIt/])
marci@317	572	// _G.graph->next((this)/.GraphInEdgeIt*/);
marci@317	573	// }
marci@317	574	// };
marci@317	575	// // //typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@317	576	// class EdgeIt : public Graph::EdgeIt {
marci@317	577	// // typedef typename Graph::EdgeIt GraphEdgeIt;
marci@317	578	// public:
marci@317	579	// EdgeIt() { }
marci@317	580	// EdgeIt(const typename Graph::EdgeIt& e) : Graph::EdgeIt(e) { }
marci@317	581	// EdgeIt(const Invalid& i) : Graph::EdgeIt(i) { }
marci@317	582	// EdgeIt(const SubGraphWrapper<Graph, NodeFilterMap, EdgeFilterMap>& _G) :
marci@317	583	// Graph::EdgeIt(*(_G.graph)) {
marci@317	584	// while (_G.graph->valid((this)/.GraphEdgeIt*/) &&
marci@317	585	// !((_G.edge_filter_map))[(this)/.GraphEdgeIt/])
marci@317	586	// _G.graph->next((this)/.GraphEdgeIt*/);
marci@317	587	// }
marci@317	588	// };
marci@317	589
marci@317	590	// NodeIt& first(NodeIt& i) const {
marci@317	591	// i=NodeIt(*this);
marci@317	592	// return i;
marci@317	593	// }
marci@317	594	// OutEdgeIt& first(OutEdgeIt& i, const Node& n) const {
marci@317	595	// i=OutEdgeIt(*this, n);
marci@317	596	// return i;
marci@317	597	// }
marci@317	598	// InEdgeIt& first(InEdgeIt& i, const Node& n) const {
marci@317	599	// i=InEdgeIt(*this, n);
marci@317	600	// return i;
marci@317	601	// }
marci@317	602	// EdgeIt& first(EdgeIt& i) const {
marci@317	603	// i=EdgeIt(*this);
marci@317	604	// return i;
marci@317	605	// }
marci@317	606
marci@317	607	// // template<typename I> I& first(I& i) const {
marci@317	608	// // graph->first(i);
marci@317	609	// // //while (graph->valid(i) && !filter_map->get(i)) { graph->next(i); }
marci@317	610	// // while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@317	611	// // return i;
marci@317	612	// // }
marci@317	613	// // template<typename I, typename P> I& first(I& i, const P& p) const {
marci@317	614	// // graph->first(i, p);
marci@317	615	// // // while (graph->valid(i) && !filter_map->get(i)) { graph->next(i); }
marci@317	616	// // while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@317	617	// // return i;
marci@317	618	// // }
marci@317	619
marci@317	620	// NodeIt& next(NodeIt& i) const {
marci@317	621	// graph->next(i);
marci@317	622	// while (graph->valid(i) && !(*node_filter_map)[i]) { graph->next(i); }
marci@317	623	// return i;
marci@317	624	// }
marci@317	625	// OutEdgeIt& next(OutEdgeIt& i) const {
marci@317	626	// graph->next(i);
marci@317	627	// while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@317	628	// return i;
marci@317	629	// }
marci@317	630	// InEdgeIt& next(InEdgeIt& i) const {
marci@317	631	// graph->next(i);
marci@317	632	// while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@317	633	// return i;
marci@317	634	// }
marci@317	635	// EdgeIt& next(EdgeIt& i) const {
marci@317	636	// graph->next(i);
marci@317	637	// while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@317	638	// return i;
marci@317	639	// }
marci@317	640
marci@317	641	// //template<typename I> I getNext(const I& i) const {
marci@317	642	// // return gw.getNext(i);
marci@317	643	// //}
marci@317	644	// // template<typename I> I& next(I &i) const {
marci@317	645	// // graph->next(i);
marci@317	646	// // // while (graph->valid(i) && !filter_map-get(i)) { graph->next(i); }
marci@317	647	// // while (graph->valid(i) && !(*edge_filter_map)[i]) { graph->next(i); }
marci@317	648	// // return i;
marci@317	649	// // }
marci@317	650
marci@317	651	// template< typename It > It first() const {
marci@317	652	// It e; this->first(e); return e; }
marci@317	653
marci@317	654	// template< typename It > It first(const Node& v) const {
marci@317	655	// It e; this->first(e, v); return e; }
marci@317	656	// };
marci@317	657
marci@238	658	// template<typename GraphWrapper>
marci@236	659	// class UndirGraphWrapper {
marci@236	660	// protected:
marci@238	661	// //Graph* graph;
marci@238	662	// GraphWrapper gw;
marci@238	663
marci@236	664	// public:
marci@303	665	// typedef GraphWrapper ParentGraph;
marci@236	666
marci@238	667	// typedef typename GraphWrapper::Node Node;
marci@238	668	// typedef typename GraphWrapper::NodeIt NodeIt;
marci@236	669
marci@236	670	// //typedef typename Graph::Edge Edge;
marci@236	671	// //typedef typename Graph::OutEdgeIt OutEdgeIt;
marci@236	672	// //typedef typename Graph::InEdgeIt InEdgeIt;
marci@236	673	// //typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@236	674	// //typedef typename Graph::EdgeIt EdgeIt;
marci@236	675
marci@236	676	// //private:
marci@238	677	// typedef typename GraphWrapper::Edge GraphEdge;
marci@238	678	// typedef typename GraphWrapper::OutEdgeIt GraphOutEdgeIt;
marci@238	679	// typedef typename GraphWrapper::InEdgeIt GraphInEdgeIt;
marci@236	680	// //public:
marci@236	681
marci@236	682	// //UndirGraphWrapper() : graph(0) { }
marci@238	683	// UndirGraphWrapper(GraphWrapper _gw) : gw(_gw) { }
marci@236	684
marci@238	685	// //void setGraph(Graph& _graph) { graph = &_graph; }
marci@238	686	// //Graph& getGraph() const { return (*graph); }
marci@236	687
marci@236	688	// class Edge {
marci@238	689	// friend class UndirGraphWrapper<GraphWrapper>;
marci@236	690	// bool out_or_in; //true iff out
marci@236	691	// GraphOutEdgeIt out;
marci@236	692	// GraphInEdgeIt in;
marci@236	693	// public:
marci@236	694	// Edge() : out_or_in(), out(), in() { }
marci@236	695	// Edge(const Invalid& i) : out_or_in(false), out(), in(i) { }
marci@236	696	// operator GraphEdge() const {
marci@236	697	// if (out_or_in) return(out); else return(in);
marci@236	698	// }
marci@236	699	// friend bool operator==(const Edge& u, const Edge& v) {
marci@236	700	// if (v.out_or_in)
marci@236	701	// return (u.out_or_in && u.out==v.out);
marci@236	702	// else
marci@236	703	// return (!u.out_or_in && u.in==v.in);
marci@236	704	// }
marci@236	705	// friend bool operator!=(const Edge& u, const Edge& v) {
marci@236	706	// if (v.out_or_in)
marci@236	707	// return (!u.out_or_in \|\| u.out!=v.out);
marci@236	708	// else
marci@236	709	// return (u.out_or_in \|\| u.in!=v.in);
marci@236	710	// }
marci@236	711	// };
marci@236	712
marci@236	713	// class OutEdgeIt : public Edge {
marci@238	714	// friend class UndirGraphWrapper<GraphWrapper>;
marci@236	715	// public:
marci@236	716	// OutEdgeIt() : Edge() { }
marci@236	717	// OutEdgeIt(const Invalid& i) : Edge(i) { }
marci@238	718	// OutEdgeIt(const UndirGraphWrapper<GraphWrapper>& _G, const Node& n)
marci@238	719	// : Edge() {
marci@236	720	// out_or_in=true;
marci@238	721	// _G.gw.first(out, n);
marci@238	722	// if (!(_G.gw.valid(out))) {
marci@236	723	// out_or_in=false;
marci@238	724	// _G.gw.first(in, n);
marci@236	725	// }
marci@236	726	// }
marci@236	727	// };
marci@236	728
marci@236	729	// OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
marci@236	730	// e.out_or_in=true;
marci@238	731	// gw.first(e.out, n);
marci@238	732	// if (!(gw.valid(e.out))) {
marci@236	733	// e.out_or_in=false;
marci@238	734	// gw.first(e.in, n);
marci@236	735	// }
marci@236	736	// return e;
marci@236	737	// }
marci@236	738
marci@236	739	// OutEdgeIt& next(OutEdgeIt& e) const {
marci@236	740	// if (e.out_or_in) {
marci@238	741	// Node n=gw.tail(e.out);
marci@238	742	// gw.next(e.out);
marci@238	743	// if (!gw.valid(e.out)) {
marci@236	744	// e.out_or_in=false;
marci@238	745	// gw.first(e.in, n);
marci@236	746	// }
marci@236	747	// } else {
marci@238	748	// gw.next(e.in);
marci@236	749	// }
marci@236	750	// return e;
marci@236	751	// }
marci@236	752
marci@236	753	// Node aNode(const OutEdgeIt& e) const {
marci@238	754	// if (e.out_or_in) return gw.tail(e); else return gw.head(e); }
marci@236	755	// Node bNode(const OutEdgeIt& e) const {
marci@238	756	// if (e.out_or_in) return gw.head(e); else return gw.tail(e); }
marci@236	757
marci@236	758	// typedef OutEdgeIt InEdgeIt;
marci@236	759
marci@238	760	// template<typename I> I& first(I& i) const { return gw.first(i); }
marci@236	761	// // template<typename I, typename P> I& first(I& i, const P& p) const {
marci@236	762	// // return graph->first(i, p); }
marci@236	763
marci@236	764	// template<typename I> I getNext(const I& i) const {
marci@238	765	// return gw.getNext(i); }
marci@238	766	// template<typename I> I& next(I &i) const { return gw.next(i); }
marci@236	767
marci@236	768	// template< typename It > It first() const {
marci@236	769	// It e; first(e); return e; }
marci@236	770
marci@236	771	// template< typename It > It first(const Node& v) const {
marci@236	772	// It e; first(e, v); return e; }
marci@236	773
marci@238	774	// Node head(const Edge& e) const { return gw.head(e); }
marci@238	775	// Node tail(const Edge& e) const { return gw.tail(e); }
marci@236	776
marci@236	777	// template<typename I> bool valid(const I& i) const
marci@238	778	// { return gw.valid(i); }
marci@236	779
marci@236	780	// //template<typename I> void setInvalid(const I &i);
marci@236	781	// //{ return graph->setInvalid(i); }
marci@236	782
marci@238	783	// int nodeNum() const { return gw.nodeNum(); }
marci@238	784	// int edgeNum() const { return gw.edgeNum(); }
marci@236	785
marci@236	786	// // template<typename I> Node aNode(const I& e) const {
marci@236	787	// // return graph->aNode(e); }
marci@236	788	// // template<typename I> Node bNode(const I& e) const {
marci@236	789	// // return graph->bNode(e); }
marci@236	790
marci@238	791	// Node addNode() const { return gw.addNode(); }
marci@236	792	// // FIXME: ez igy nem jo, mert nem
marci@236	793	// // Edge addEdge(const Node& tail, const Node& head) const {
marci@236	794	// // return graph->addEdge(tail, head); }
marci@236	795
marci@238	796	// template<typename I> void erase(const I& i) const { gw.erase(i); }
marci@236	797
marci@238	798	// void clear() const { gw.clear(); }
marci@236	799
marci@238	800	// template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> {
marci@236	801	// public:
marci@238	802	// NodeMap(const UndirGraphWrapper<GraphWrapper>& _G) :
marci@238	803	// GraphWrapper::NodeMap<T>(_G.gw) { }
marci@238	804	// NodeMap(const UndirGraphWrapper<GraphWrapper>& _G, T a) :
marci@238	805	// GraphWrapper::NodeMap<T>(_G.gw, a) { }
marci@236	806	// };
marci@236	807
marci@238	808	// template<typename T> class EdgeMap : public GraphWrapper::EdgeMap<T> {
marci@236	809	// public:
marci@238	810	// EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G) :
marci@238	811	// GraphWrapper::EdgeMap<T>(_G.gw) { }
marci@238	812	// EdgeMap(const UndirGraphWrapper<GraphWrapper>& _G, T a) :
marci@238	813	// GraphWrapper::EdgeMap<T>(_G.gw, a) { }
marci@236	814	// };
marci@236	815	// };
marci@236	816
marci@236	817
marci@303	818	template<typename Graph>
marci@303	819	class UndirGraphWrapper : public GraphWrapper<Graph> {
marci@317	820	// protected:
marci@317	821	// typedef typename Graph::Edge GraphEdge;
marci@317	822	// typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
marci@317	823	// typedef typename Graph::InEdgeIt GraphInEdgeIt;
marci@303	824	public:
marci@303	825	typedef typename GraphWrapper<Graph>::Node Node;
marci@303	826	typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
marci@317	827	typedef typename GraphWrapper<Graph>::Edge Edge;
marci@317	828	typedef typename GraphWrapper<Graph>::EdgeIt EdgeIt;
marci@236	829
marci@303	830	// UndirGraphWrapper() : GraphWrapper<Graph>() { }
marci@303	831	UndirGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { }
marci@158	832
marci@317	833
marci@317	834	// class Edge {
marci@317	835	// friend class UndirGraphWrapper<Graph>;
marci@317	836	// protected:
marci@317	837	// bool out_or_in; //true iff out
marci@317	838	// GraphOutEdgeIt out;
marci@317	839	// GraphInEdgeIt in;
marci@317	840	// public:
marci@317	841	// Edge() : out_or_in(), out(), in() { }
marci@317	842	// Edge(const Invalid& i) : out_or_in(false), out(), in(i) { }
marci@317	843	// operator GraphEdge() const {
marci@317	844	// if (out_or_in) return(out); else return(in);
marci@317	845	// }
marci@317	846	// //FIXME
marci@317	847	// //2 edges are equal if they "refer" to the same physical edge
marci@317	848	// //is it good?
marci@317	849	// friend bool operator==(const Edge& u, const Edge& v) {
marci@317	850	// if (v.out_or_in)
marci@317	851	// if (u.out_or_in) return (u.out==v.out); else return (u.out==v.in);
marci@317	852	// //return (u.out_or_in && u.out==v.out);
marci@317	853	// else
marci@317	854	// if (u.out_or_in) return (u.out==v.in); else return (u.in==v.in);
marci@317	855	// //return (!u.out_or_in && u.in==v.in);
marci@317	856	// }
marci@317	857	// friend bool operator!=(const Edge& u, const Edge& v) {
marci@317	858	// if (v.out_or_in)
marci@317	859	// if (u.out_or_in) return (u.out!=v.out); else return (u.out!=v.in);
marci@317	860	// //return (!u.out_or_in \|\| u.out!=v.out);
marci@317	861	// else
marci@317	862	// if (u.out_or_in) return (u.out!=v.in); else return (u.in!=v.in);
marci@317	863	// //return (u.out_or_in \|\| u.in!=v.in);
marci@317	864	// }
marci@317	865	// };
marci@317	866
marci@317	867	class OutEdgeIt {
marci@303	868	friend class UndirGraphWrapper<Graph>;
marci@158	869	bool out_or_in; //true iff out
marci@317	870	typename Graph::OutEdgeIt out;
marci@317	871	typename Graph::InEdgeIt in;
marci@158	872	public:
marci@317	873	OutEdgeIt() { }
marci@317	874	OutEdgeIt(const Invalid& i) : Edge(i) { }
marci@317	875	OutEdgeIt(const UndirGraphWrapper<Graph>& _G, const Node& _n) {
marci@317	876	out_or_in=true; _G.graph->first(out, _n);
marci@317	877	if (!(_G.graph->valid(out))) { out_or_in=false; _G.graph->first(in, _n); }
marci@174	878	}
marci@317	879	operator Edge() const {
marci@317	880	if (out_or_in) return Edge(out); else return Edge(in);
marci@158	881	}
marci@158	882	};
marci@317	883	// class OutEdgeIt : public Edge {
marci@317	884	// friend class UndirGraphWrapper<Graph>;
marci@317	885	// public:
marci@317	886	// OutEdgeIt() : Edge() { }
marci@317	887	// OutEdgeIt(const Invalid& i) : Edge(i) { }
marci@317	888	// OutEdgeIt(const UndirGraphWrapper<Graph>& _G, const Node& n)
marci@317	889	// : Edge() {
marci@317	890	// out_or_in=true; _G.graph->first(out, n);
marci@317	891	// if (!(_G.graph->valid(out))) { out_or_in=false; _G.graph->first(in, n); }
marci@317	892	// }
marci@317	893	// };
marci@158	894
marci@317	895	//FIXME InEdgeIt
marci@238	896	typedef OutEdgeIt InEdgeIt;
marci@238	897
marci@317	898	// class EdgeIt : public Edge {
marci@317	899	// friend class UndirGraphWrapper<Graph>;
marci@317	900	// protected:
marci@317	901	// NodeIt v;
marci@317	902	// public:
marci@317	903	// EdgeIt() : Edge() { }
marci@317	904	// EdgeIt(const Invalid& i) : Edge(i) { }
marci@317	905	// EdgeIt(const UndirGraphWrapper<Graph>& _G)
marci@317	906	// : Edge() {
marci@317	907	// out_or_in=true;
marci@317	908	// //Node v;
marci@317	909	// _G.first(v);
marci@317	910	// if (_G.valid(v)) _G.graph->first(out); else out=INVALID;
marci@317	911	// while (_G.valid(v) && !_G.graph->valid(out)) {
marci@317	912	// _G.graph->next(v);
marci@317	913	// if (_G.valid(v)) _G.graph->first(out);
marci@317	914	// }
marci@317	915	// }
marci@317	916	// };
marci@238	917
marci@317	918	NodeIt& first(NodeIt& i) const {
marci@317	919	i=NodeIt(*this); return i;
marci@158	920	}
marci@317	921	OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
marci@317	922	i=OutEdgeIt(*this, p); return i;
marci@317	923	}
marci@317	924	//FIXME
marci@317	925	// InEdgeIt& first(InEdgeIt& i, const Node& p) const {
marci@317	926	// i=InEdgeIt(*this, p); return i;
marci@317	927	// }
marci@317	928	EdgeIt& first(EdgeIt& i) const {
marci@317	929	i=EdgeIt(*this); return i;
marci@238	930	}
marci@238	931
marci@303	932	template<typename I> I& first(I& i) const { graph->first(i); return i; }
marci@238	933	template<typename I, typename P> I& first(I& i, const P& p) const {
marci@303	934	graph->first(i, p); return i; }
marci@238	935
marci@317	936	NodeIt& next(NodeIt& n) const {
marci@317	937	GraphWrapper<Graph>::next(n);
marci@317	938	return n;
marci@317	939	}
marci@158	940	OutEdgeIt& next(OutEdgeIt& e) const {
marci@158	941	if (e.out_or_in) {
marci@317	942	typename Graph::Node n=graph->tail(e.out);
marci@303	943	graph->next(e.out);
marci@303	944	if (!graph->valid(e.out)) { e.out_or_in=false; graph->first(e.in, n); }
marci@158	945	} else {
marci@303	946	graph->next(e.in);
marci@158	947	}
marci@158	948	return e;
marci@158	949	}
marci@317	950	//FIXME InEdgeIt
marci@238	951	EdgeIt& next(EdgeIt& e) const {
marci@317	952	GraphWrapper<Graph>::next(n);
marci@317	953	// graph->next(e.e);
marci@238	954	return e;
marci@238	955	}
marci@158	956
marci@317	957	// template<typename I> I& next(I &i) const { graph->next(i); return i; }
marci@265	958	// template<typename I> I getNext(const I& i) const { return gw.getNext(i); }
marci@158	959
marci@158	960	template< typename It > It first() const {
marci@303	961	It e; this->first(e); return e; }
marci@158	962
marci@174	963	template< typename It > It first(const Node& v) const {
marci@303	964	It e; this->first(e, v); return e; }
marci@158	965
marci@238	966	// Node head(const Edge& e) const { return gw.head(e); }
marci@238	967	// Node tail(const Edge& e) const { return gw.tail(e); }
marci@158	968
marci@238	969	// template<typename I> bool valid(const I& i) const
marci@238	970	// { return gw.valid(i); }
marci@158	971
marci@238	972	// int nodeNum() const { return gw.nodeNum(); }
marci@238	973	// int edgeNum() const { return gw.edgeNum(); }
marci@158	974
marci@174	975	// template<typename I> Node aNode(const I& e) const {
marci@158	976	// return graph->aNode(e); }
marci@174	977	// template<typename I> Node bNode(const I& e) const {
marci@158	978	// return graph->bNode(e); }
marci@238	979
marci@238	980	Node aNode(const OutEdgeIt& e) const {
marci@303	981	if (e.out_or_in) return graph->tail(e); else return graph->head(e); }
marci@238	982	Node bNode(const OutEdgeIt& e) const {
marci@303	983	if (e.out_or_in) return graph->head(e); else return graph->tail(e); }
marci@158	984
marci@238	985	// Node addNode() const { return gw.addNode(); }
marci@238	986
marci@231	987	// FIXME: ez igy nem jo, mert nem
marci@231	988	// Edge addEdge(const Node& tail, const Node& head) const {
marci@231	989	// return graph->addEdge(tail, head); }
marci@158	990
marci@238	991	// template<typename I> void erase(const I& i) const { gw.erase(i); }
marci@158	992
marci@238	993	// void clear() const { gw.clear(); }
marci@158	994
marci@303	995	// template<typename T> class NodeMap : public Graph::NodeMap<T> {
marci@238	996	// public:
marci@303	997	// NodeMap(const UndirGraphWrapper<Graph>& _G) :
marci@303	998	// Graph::NodeMap<T>(_G.gw) { }
marci@303	999	// NodeMap(const UndirGraphWrapper<Graph>& _G, T a) :
marci@303	1000	// Graph::NodeMap<T>(_G.gw, a) { }
marci@238	1001	// };
marci@168	1002
marci@238	1003	// template<typename T> class EdgeMap :
marci@303	1004	// public GraphWrapperSkeleton<Graph>::EdgeMap<T> {
marci@238	1005	// public:
marci@303	1006	// EdgeMap(const UndirGraphWrapper<Graph>& _G) :
marci@303	1007	// GraphWrapperSkeleton<Graph>::EdgeMap<T>(_G.gw) { }
marci@303	1008	// EdgeMap(const UndirGraphWrapper<Graph>& _G, T a) :
marci@303	1009	// Graph::EdgeMap<T>(_G.gw, a) { }
marci@238	1010	// };
marci@238	1011	};
marci@158	1012
marci@158	1013
marci@158	1014
marci@236	1015
marci@236	1016
marci@155	1017	// template<typename Graph>
marci@155	1018	// class SymGraphWrapper
marci@155	1019	// {
marci@155	1020	// Graph* graph;
marci@76	1021
marci@155	1022	// public:
marci@303	1023	// typedef Graph ParentGraph;
marci@155	1024
marci@174	1025	// typedef typename Graph::Node Node;
marci@174	1026	// typedef typename Graph::Edge Edge;
marci@174	1027
marci@155	1028	// typedef typename Graph::NodeIt NodeIt;
marci@155	1029
marci@155	1030	// //FIXME tag-ekkel megcsinalni, hogy abbol csinaljon
marci@155	1031	// //iranyitatlant, ami van
marci@155	1032	// //mert csak 1 dolgot lehet be typedef-elni
marci@155	1033	// typedef typename Graph::OutEdgeIt SymEdgeIt;
marci@155	1034	// //typedef typename Graph::InEdgeIt SymEdgeIt;
marci@155	1035	// //typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@174	1036	// typedef typename Graph::EdgeIt EdgeIt;
marci@155	1037
marci@155	1038	// int nodeNum() const { return graph->nodeNum(); }
marci@155	1039	// int edgeNum() const { return graph->edgeNum(); }
marci@155	1040
marci@212	1041	// template<typename I> I& first(I& i) const { return graph->first(i); }
marci@212	1042	// template<typename I, typename P> I& first(I& i, const P& p) const {
marci@212	1043	// return graph->first(i, p); }
marci@155	1044	// //template<typename I> I next(const I i); { return graph->goNext(i); }
marci@155	1045	// //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
marci@155	1046
marci@155	1047	// template< typename It > It first() const {
marci@212	1048	// It e; first(e); return e; }
marci@155	1049
marci@174	1050	// template< typename It > It first(Node v) const {
marci@212	1051	// It e; first(e, v); return e; }
marci@155	1052
marci@174	1053	// Node head(const Edge& e) const { return graph->head(e); }
marci@174	1054	// Node tail(const Edge& e) const { return graph->tail(e); }
marci@155	1055
marci@174	1056	// template<typename I> Node aNode(const I& e) const {
marci@155	1057	// return graph->aNode(e); }
marci@174	1058	// template<typename I> Node bNode(const I& e) const {
marci@155	1059	// return graph->bNode(e); }
marci@155	1060
marci@155	1061	// //template<typename I> bool valid(const I i);
marci@155	1062	// //{ return graph->valid(i); }
marci@155	1063
marci@155	1064	// //template<typename I> void setInvalid(const I &i);
marci@155	1065	// //{ return graph->setInvalid(i); }
marci@155	1066
marci@174	1067	// Node addNode() { return graph->addNode(); }
marci@174	1068	// Edge addEdge(const Node& tail, const Node& head) {
marci@155	1069	// return graph->addEdge(tail, head); }
marci@155	1070
marci@155	1071	// template<typename I> void erase(const I& i) { graph->erase(i); }
marci@155	1072
marci@155	1073	// void clear() { graph->clear(); }
marci@155	1074
marci@155	1075	// template<typename T> class NodeMap : public Graph::NodeMap<T> { };
marci@155	1076	// template<typename T> class EdgeMap : public Graph::EdgeMap<T> { };
marci@155	1077
marci@155	1078	// void setGraph(Graph& _graph) { graph = &_graph; }
marci@155	1079	// Graph& getGraph() { return (*graph); }
marci@155	1080
marci@155	1081	// //SymGraphWrapper() : graph(0) { }
marci@155	1082	// SymGraphWrapper(Graph& _graph) : graph(&_graph) { }
marci@155	1083	// };
marci@155	1084
marci@155	1085
marci@317	1086
marci@317	1087
marci@303	1088	template<typename Graph, typename Number, typename FlowMap, typename CapacityMap>
marci@311	1089	class ResGraphWrapper : public GraphWrapper<Graph> {
marci@199	1090	protected:
marci@317	1091	// typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
marci@317	1092	// typedef typename Graph::InEdgeIt GraphInEdgeIt;
marci@317	1093	// typedef typename Graph::Edge GraphEdge;
marci@155	1094	FlowMap* flow;
marci@155	1095	const CapacityMap* capacity;
marci@155	1096	public:
marci@168	1097
marci@303	1098	ResGraphWrapper(Graph& _graph, FlowMap& _flow,
marci@266	1099	const CapacityMap& _capacity) :
marci@303	1100	GraphWrapper<Graph>(_graph), flow(&_flow), capacity(&_capacity) { }
marci@168	1101
marci@174	1102	class Edge;
marci@155	1103	class OutEdgeIt;
marci@174	1104	friend class Edge;
marci@155	1105	friend class OutEdgeIt;
marci@76	1106
marci@311	1107	typedef typename GraphWrapper<Graph>::Node Node;
marci@311	1108	typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
marci@317	1109	class Edge : public Graph::Edge {
marci@303	1110	friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@155	1111	protected:
marci@317	1112	bool forward; //true, iff forward
marci@317	1113	// typename Graph::Edge e;
marci@155	1114	public:
marci@317	1115	Edge() { }
marci@317	1116	Edge(const typename Graph::Edge& _e, bool _forward) :
marci@317	1117	Graph::Edge(_e), forward(_forward) { }
marci@317	1118	Edge(const Invalid& i) : Graph::Edge(i), forward(false) { }
marci@317	1119	//the unique invalid iterator
marci@174	1120	friend bool operator==(const Edge& u, const Edge& v) {
marci@317	1121	return (v.forward==u.forward &&
marci@317	1122	static_cast<typename Graph::Edge>(u)==
marci@317	1123	static_cast<typename Graph::Edge>(v));
marci@174	1124	}
marci@174	1125	friend bool operator!=(const Edge& u, const Edge& v) {
marci@317	1126	return (v.forward!=u.forward \|\|
marci@317	1127	static_cast<typename Graph::Edge>(u)!=
marci@317	1128	static_cast<typename Graph::Edge>(v));
marci@174	1129	}
marci@155	1130	};
marci@317	1131	// class Edge {
marci@317	1132	// friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1133	// protected:
marci@317	1134	// bool out_or_in; //true, iff out
marci@317	1135	// GraphOutEdgeIt out;
marci@317	1136	// GraphInEdgeIt in;
marci@317	1137	// public:
marci@317	1138	// Edge() : out_or_in(true) { }
marci@317	1139	// Edge(const Invalid& i) : out_or_in(false), out(), in(i) { }
marci@317	1140	// // bool valid() const {
marci@317	1141	// // return out_or_in && out.valid() \|\| in.valid(); }
marci@317	1142	// friend bool operator==(const Edge& u, const Edge& v) {
marci@317	1143	// if (v.out_or_in)
marci@317	1144	// return (u.out_or_in && u.out==v.out);
marci@317	1145	// else
marci@317	1146	// return (!u.out_or_in && u.in==v.in);
marci@317	1147	// }
marci@317	1148	// friend bool operator!=(const Edge& u, const Edge& v) {
marci@317	1149	// if (v.out_or_in)
marci@317	1150	// return (!u.out_or_in \|\| u.out!=v.out);
marci@317	1151	// else
marci@317	1152	// return (u.out_or_in \|\| u.in!=v.in);
marci@317	1153	// }
marci@317	1154	// operator GraphEdge() const {
marci@317	1155	// if (out_or_in) return(out); else return(in);
marci@317	1156	// }
marci@317	1157	// };
marci@317	1158	class OutEdgeIt {
marci@303	1159	friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1160	protected:
marci@317	1161	typename Graph::OutEdgeIt out;
marci@317	1162	typename Graph::InEdgeIt in;
marci@317	1163	bool forward;
marci@155	1164	public:
marci@155	1165	OutEdgeIt() { }
marci@168	1166	//FIXME
marci@317	1167	// OutEdgeIt(const Edge& e) : Edge(e) { }
marci@317	1168	OutEdgeIt(const Invalid& i) : out(i), in(i), forward(false) { }
marci@317	1169	//the unique invalid iterator
marci@317	1170	OutEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, Node v) {
marci@317	1171	forward=true;
marci@303	1172	resG.graph->first(out, v);
marci@317	1173	while( resG.graph->valid(out) && !(resG.resCap(*this)>0) ) { resG.graph->next(out); }
marci@303	1174	if (!resG.graph->valid(out)) {
marci@317	1175	forward=false;
marci@303	1176	resG.graph->first(in, v);
marci@317	1177	while( resG.graph->valid(in) && !(resG.resCap(*this)>0) ) { resG.graph->next(in); }
marci@155	1178	}
marci@155	1179	}
marci@317	1180	operator Edge() const {
marci@317	1181	// Edge e;
marci@317	1182	// e.forward=this->forward;
marci@317	1183	// if (this->forward) e=out; else e=in;
marci@317	1184	// return e;
marci@317	1185	if (this->forward)
marci@317	1186	return Edge(out, this->forward);
marci@317	1187	else
marci@317	1188	return Edge(in, this->forward);
marci@317	1189	}
marci@317	1190	};
marci@317	1191	// class OutEdgeIt : public Edge {
marci@317	1192	// friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1193	// public:
marci@317	1194	// OutEdgeIt() { }
marci@317	1195	// //FIXME
marci@317	1196	// OutEdgeIt(const Edge& e) : Edge(e) { }
marci@317	1197	// OutEdgeIt(const Invalid& i) : Edge(i) { }
marci@317	1198	// OutEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, Node v) : Edge() {
marci@317	1199	// resG.graph->first(out, v);
marci@317	1200	// while( resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
marci@317	1201	// if (!resG.graph->valid(out)) {
marci@317	1202	// out_or_in=0;
marci@317	1203	// resG.graph->first(in, v);
marci@317	1204	// while( resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
marci@317	1205	// }
marci@317	1206	// }
marci@168	1207	// public:
marci@168	1208	// OutEdgeIt& operator++() {
marci@168	1209	// if (out_or_in) {
marci@174	1210	// Node v=/resG->/G->aNode(out);
marci@168	1211	// ++out;
marci@269	1212	// while( out.valid() && !(Edge::resCap()>0) ) { ++out; }
marci@168	1213	// if (!out.valid()) {
marci@168	1214	// out_or_in=0;
marci@212	1215	// G->first(in, v);
marci@269	1216	// while( in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@168	1217	// }
marci@168	1218	// } else {
marci@168	1219	// ++in;
marci@269	1220	// while( in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@168	1221	// }
marci@168	1222	// return *this;
marci@168	1223	// }
marci@317	1224	// };
marci@155	1225
marci@263	1226	//FIXME This is just for having InEdgeIt
marci@311	1227	// class InEdgeIt : public Edge { };
marci@263	1228
marci@317	1229	class InEdgeIt {
marci@303	1230	friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1231	protected:
marci@317	1232	typename Graph::OutEdgeIt out;
marci@317	1233	typename Graph::InEdgeIt in;
marci@317	1234	bool forward;
marci@317	1235	public:
marci@317	1236	InEdgeIt() { }
marci@317	1237	//FIXME
marci@317	1238	// OutEdgeIt(const Edge& e) : Edge(e) { }
marci@317	1239	InEdgeIt(const Invalid& i) : out(i), in(i), forward(false) { }
marci@317	1240	//the unique invalid iterator
marci@317	1241	InEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, Node v) {
marci@317	1242	forward=true;
marci@317	1243	resG.graph->first(in, v);
marci@317	1244	while( resG.graph->valid(in) && !(resG.resCap(*this)>0) ) { resG.graph->next(in); }
marci@317	1245	if (!resG.graph->valid(in)) {
marci@317	1246	forward=false;
marci@317	1247	resG.graph->first(out, v);
marci@317	1248	while( resG.graph->valid(out) && !(resG.resCap(*this)>0) ) { resG.graph->next(out); }
marci@317	1249	}
marci@317	1250	}
marci@317	1251	operator Edge() const {
marci@317	1252	// Edge e;
marci@317	1253	// e.forward=this->forward;
marci@317	1254	// if (this->forward) e=out; else e=in;
marci@317	1255	// return e;
marci@317	1256	if (this->forward)
marci@317	1257	return Edge(in, this->forward);
marci@317	1258	else
marci@317	1259	return Edge(out, this->forward);
marci@317	1260	}
marci@317	1261	};
marci@317	1262
marci@317	1263	class EdgeIt {
marci@317	1264	friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1265	protected:
marci@317	1266	typename Graph::EdgeIt e;
marci@317	1267	bool forward;
marci@155	1268	public:
marci@174	1269	EdgeIt() { }
marci@317	1270	EdgeIt(const Invalid& i) : e(i), forward(false) { }
marci@317	1271	EdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG) {
marci@317	1272	forward=true;
marci@317	1273	resG.graph->first(e);
marci@317	1274	while (resG.graph->valid(e) && !(resG.resCap(*this)>0)) resG.graph->next(e);
marci@317	1275	if (!resG.graph->valid(e)) {
marci@317	1276	forward=false;
marci@317	1277	resG.graph->first(e);
marci@317	1278	while (resG.graph->valid(e) && !(resG.resCap(*this)>0)) resG.graph->next(e);
marci@155	1279	}
marci@155	1280	}
marci@317	1281	operator Edge() const {
marci@317	1282	return Edge(e, this->forward);
marci@317	1283	}
marci@317	1284	};
marci@317	1285	// class EdgeIt : public Edge {
marci@317	1286	// friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1287	// NodeIt v;
marci@317	1288	// public:
marci@317	1289	// EdgeIt() { }
marci@317	1290	// //EdgeIt(const EdgeIt& e) : Edge(e), v(e.v) { }
marci@317	1291	// EdgeIt(const Invalid& i) : Edge(i) { }
marci@317	1292	// EdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG) : Edge() {
marci@317	1293	// resG.graph->first(v);
marci@317	1294	// if (resG.graph->valid(v)) resG.graph->first(out, v); else out=INVALID;
marci@317	1295	// while (resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
marci@317	1296	// while (resG.graph->valid(v) && !resG.graph->valid(out)) {
marci@317	1297	// resG.graph->next(v);
marci@317	1298	// if (resG.graph->valid(v)) resG.graph->first(out, v);
marci@317	1299	// while (resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
marci@317	1300	// }
marci@317	1301	// if (!resG.graph->valid(out)) {
marci@317	1302	// out_or_in=0;
marci@317	1303	// resG.graph->first(v);
marci@317	1304	// if (resG.graph->valid(v)) resG.graph->first(in, v); else in=INVALID;
marci@317	1305	// while (resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
marci@317	1306	// while (resG.graph->valid(v) && !resG.graph->valid(in)) {
marci@317	1307	// resG.graph->next(v);
marci@317	1308	// if (resG.graph->valid(v)) resG.graph->first(in, v);
marci@317	1309	// while (resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
marci@317	1310	// }
marci@317	1311	// }
marci@317	1312	// }
marci@174	1313	// EdgeIt& operator++() {
marci@168	1314	// if (out_or_in) {
marci@168	1315	// ++out;
marci@269	1316	// while (out.valid() && !(Edge::resCap()>0) ) { ++out; }
marci@168	1317	// while (v.valid() && !out.valid()) {
marci@168	1318	// ++v;
marci@212	1319	// if (v.valid()) G->first(out, v);
marci@269	1320	// while (out.valid() && !(Edge::resCap()>0) ) { ++out; }
marci@168	1321	// }
marci@168	1322	// if (!out.valid()) {
marci@168	1323	// out_or_in=0;
marci@212	1324	// G->first(v);
marci@303	1325	// if (v.valid()) G->first(in, v); else in=GraphInEdgeIt();
marci@269	1326	// while (in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@168	1327	// while (v.valid() && !in.valid()) {
marci@168	1328	// ++v;
marci@212	1329	// if (v.valid()) G->first(in, v);
marci@269	1330	// while (in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@168	1331	// }
marci@168	1332	// }
marci@168	1333	// } else {
marci@168	1334	// ++in;
marci@269	1335	// while (in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@168	1336	// while (v.valid() && !in.valid()) {
marci@168	1337	// ++v;
marci@212	1338	// if (v.valid()) G->first(in, v);
marci@269	1339	// while (in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@168	1340	// }
marci@168	1341	// }
marci@168	1342	// return *this;
marci@168	1343	// }
marci@317	1344	// };
marci@155	1345
marci@311	1346	NodeIt& first(NodeIt& i) const {
marci@317	1347	i=NodeIt(*this); return i;
marci@155	1348	}
marci@311	1349	OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
marci@317	1350	i=OutEdgeIt(*this, p); return i;
marci@311	1351	}
marci@317	1352	// FIXME not tested
marci@317	1353	InEdgeIt& first(InEdgeIt& i, const Node& p) const {
marci@317	1354	i=InEdgeIt(*this, p); return i;
marci@317	1355	}
marci@317	1356	EdgeIt& first(EdgeIt& i) const {
marci@317	1357	i=EdgeIt(*this); return i;
marci@155	1358	}
marci@155	1359
marci@317	1360	NodeIt& next(NodeIt& n) const { GraphWrapper<Graph>::next(n); return n; }
marci@155	1361	OutEdgeIt& next(OutEdgeIt& e) const {
marci@317	1362	if (e.forward) {
marci@303	1363	Node v=graph->aNode(e.out);
marci@303	1364	graph->next(e.out);
marci@317	1365	while( graph->valid(e.out) && !(resCap(e)>0) ) { graph->next(e.out); }
marci@303	1366	if (!graph->valid(e.out)) {
marci@317	1367	e.forward=false;
marci@303	1368	graph->first(e.in, v);
marci@317	1369	while( graph->valid(e.in) && !(resCap(e)>0) ) { graph->next(e.in); }
marci@155	1370	}
marci@155	1371	} else {
marci@303	1372	graph->next(e.in);
marci@317	1373	while( graph->valid(e.in) && !(resCap(e)>0) ) { graph->next(e.in); }
marci@155	1374	}
marci@155	1375	return e;
marci@155	1376	}
marci@317	1377	// FIXME Not tested
marci@317	1378	InEdgeIt& next(InEdgeIt& e) const {
marci@317	1379	if (e.forward) {
marci@317	1380	Node v=graph->aNode(e.in);
marci@317	1381	graph->next(e.in);
marci@317	1382	while( graph->valid(e.in) && !(resCap(e)>0) ) { graph->next(e.in); }
marci@317	1383	if (!graph->valid(e.in)) {
marci@317	1384	e.forward=false;
marci@317	1385	graph->first(e.out, v);
marci@317	1386	while( graph->valid(e.out) && !(resCap(e)>0) ) { graph->next(e.out); }
marci@317	1387	}
marci@317	1388	} else {
marci@303	1389	graph->next(e.out);
marci@317	1390	while( graph->valid(e.out) && !(resCap(e)>0) ) { graph->next(e.out); }
marci@317	1391	}
marci@317	1392	return e;
marci@317	1393	}
marci@317	1394	EdgeIt& next(EdgeIt& e) const {
marci@317	1395	if (e.forward) {
marci@317	1396	graph->next(e.e);
marci@317	1397	while( graph->valid(e.e) && !(resCap(e)>0) ) { graph->next(e.e); }
marci@317	1398	if (!graph->valid(e.e)) {
marci@317	1399	e.forward=false;
marci@317	1400	graph->first(e.e);
marci@317	1401	while( graph->valid(e.e) && !(resCap(e)>0) ) { graph->next(e.e); }
marci@155	1402	}
marci@317	1403	} else {
marci@317	1404	graph->next(e.e);
marci@317	1405	while( graph->valid(e.e) && !(resCap(e)>0) ) { graph->next(e.e); }
marci@155	1406	}
marci@317	1407	return e;
marci@317	1408	}
marci@317	1409	// EdgeIt& next(EdgeIt& e) const {
marci@317	1410	// if (e.out_or_in) {
marci@317	1411	// graph->next(e.out);
marci@317	1412	// while (graph->valid(e.out) && !(resCap(e.out)>0) ) { graph->next(e.out); }
marci@317	1413	// while (graph->valid(e.v) && !graph->valid(e.out)) {
marci@317	1414	// graph->next(e.v);
marci@317	1415	// if (graph->valid(e.v)) graph->first(e.out, e.v);
marci@317	1416	// while (graph->valid(e.out) && !(resCap(e.out)>0) ) { graph->next(e.out); }
marci@317	1417	// }
marci@317	1418	// if (!graph->valid(e.out)) {
marci@317	1419	// e.out_or_in=0;
marci@317	1420	// graph->first(e.v);
marci@317	1421	// if (graph->valid(e.v)) graph->first(e.in, e.v); else e.in=INVALID;
marci@317	1422	// while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1423	// while (graph->valid(e.v) && !graph->valid(e.in)) {
marci@317	1424	// graph->next(e.v);
marci@317	1425	// if (graph->valid(e.v)) graph->first(e.in, e.v);
marci@317	1426	// while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1427	// }
marci@317	1428	// }
marci@317	1429	// } else {
marci@317	1430	// graph->next(e.in);
marci@317	1431	// while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1432	// while (graph->valid(e.v) && !graph->valid(e.in)) {
marci@317	1433	// graph->next(e.v);
marci@317	1434	// if (graph->valid(e.v)) graph->first(e.in, e.v);
marci@317	1435	// while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1436	// }
marci@317	1437	// }
marci@317	1438	// return e;
marci@317	1439	// }
marci@76	1440
marci@76	1441
marci@155	1442	template< typename It >
marci@155	1443	It first() const {
marci@155	1444	It e;
marci@212	1445	first(e);
marci@155	1446	return e;
marci@155	1447	}
marci@76	1448
marci@155	1449	template< typename It >
marci@174	1450	It first(Node v) const {
marci@155	1451	It e;
marci@212	1452	first(e, v);
marci@155	1453	return e;
marci@155	1454	}
marci@76	1455
marci@174	1456	Node tail(Edge e) const {
marci@317	1457	return ((e.forward) ? graph->tail(e) : graph->head(e)); }
marci@174	1458	Node head(Edge e) const {
marci@317	1459	return ((e.forward) ? graph->head(e) : graph->tail(e)); }
marci@76	1460
marci@174	1461	Node aNode(OutEdgeIt e) const {
marci@317	1462	return ((e.forward) ? graph->aNode(e.out) : graph->aNode(e.in)); }
marci@174	1463	Node bNode(OutEdgeIt e) const {
marci@317	1464	return ((e.forward) ? graph->bNode(e.out) : graph->bNode(e.in)); }
marci@76	1465
marci@303	1466	int nodeNum() const { return graph->nodeNum(); }
marci@263	1467	//FIXME
marci@303	1468	//int edgeNum() const { return graph->edgeNum(); }
marci@263	1469
marci@263	1470
marci@317	1471	// int id(Node v) const { return graph->id(v); }
marci@155	1472
marci@317	1473	bool valid(Node n) const { return GraphWrapper<Graph>::valid(n); }
marci@174	1474	bool valid(Edge e) const {
marci@317	1475	return graph->valid(e);
marci@317	1476	//return e.forward ? graph->valid(e.out) : graph->valid(e.in);
marci@317	1477	}
marci@155	1478
marci@174	1479	void augment(const Edge& e, Number a) const {
marci@317	1480	if (e.forward)
marci@303	1481	// flow->set(e.out, flow->get(e.out)+a);
marci@317	1482	flow->set(e, (*flow)[e]+a);
marci@168	1483	else
marci@303	1484	// flow->set(e.in, flow->get(e.in)-a);
marci@317	1485	flow->set(e, (*flow)[e]-a);
marci@168	1486	}
marci@168	1487
marci@269	1488	Number resCap(const Edge& e) const {
marci@317	1489	if (e.forward)
marci@303	1490	// return (capacity->get(e.out)-flow->get(e.out));
marci@317	1491	return ((capacity)[e]-(flow)[e]);
marci@168	1492	else
marci@303	1493	// return (flow->get(e.in));
marci@317	1494	return ((*flow)[e]);
marci@168	1495	}
marci@168	1496
marci@317	1497	// Number resCap(typename Graph::OutEdgeIt out) const {
marci@317	1498	// // return (capacity->get(out)-flow->get(out));
marci@317	1499	// return ((capacity)[out]-(flow)[out]);
marci@317	1500	// }
marci@168	1501
marci@317	1502	// Number resCap(typename Graph::InEdgeIt in) const {
marci@317	1503	// // return (flow->get(in));
marci@317	1504	// return ((*flow)[in]);
marci@317	1505	// }
marci@168	1506
marci@303	1507	// template<typename T> class NodeMap : public Graph::NodeMap<T> {
marci@266	1508	// public:
marci@303	1509	// NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G)
marci@303	1510	// : Graph::NodeMap<T>(_G.gw) { }
marci@303	1511	// NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G,
marci@303	1512	// T a) : Graph::NodeMap<T>(_G.gw, a) { }
marci@266	1513	// };
marci@155	1514
marci@155	1515	// template <typename T>
marci@155	1516	// class NodeMap {
marci@155	1517	// typename Graph::NodeMap<T> node_map;
marci@155	1518	// public:
marci@174	1519	// NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : node_map(*(_G.graph)) { }
marci@174	1520	// NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : node_map(*(_G.graph), a) { }
marci@174	1521	// void set(Node nit, T a) { node_map.set(nit, a); }
marci@174	1522	// T get(Node nit) const { return node_map.get(nit); }
marci@155	1523	// };
marci@155	1524
marci@155	1525	template <typename T>
marci@155	1526	class EdgeMap {
marci@303	1527	typename Graph::EdgeMap<T> forward_map, backward_map;
marci@155	1528	public:
marci@303	1529	EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : forward_map((_G.graph)), backward_map((_G.graph)) { }
marci@303	1530	EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : forward_map((_G.graph), a), backward_map((_G.graph), a) { }
marci@174	1531	void set(Edge e, T a) {
marci@317	1532	if (e.forward)
marci@155	1533	forward_map.set(e.out, a);
marci@155	1534	else
marci@155	1535	backward_map.set(e.in, a);
marci@155	1536	}
marci@303	1537	T operator[](Edge e) const {
marci@317	1538	if (e.forward)
marci@303	1539	return forward_map[e.out];
marci@155	1540	else
marci@303	1541	return backward_map[e.in];
marci@155	1542	}
marci@303	1543	// T get(Edge e) const {
marci@303	1544	// if (e.out_or_in)
marci@303	1545	// return forward_map.get(e.out);
marci@303	1546	// else
marci@303	1547	// return backward_map.get(e.in);
marci@303	1548	// }
marci@155	1549	};
marci@168	1550	};
marci@168	1551
marci@317	1552
marci@317	1553
marci@317	1554	// template<typename Graph, typename Number, typename FlowMap, typename CapacityMap>
marci@317	1555	// class ResGraphWrapper : public GraphWrapper<Graph> {
marci@317	1556	// protected:
marci@317	1557	// typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
marci@317	1558	// typedef typename Graph::InEdgeIt GraphInEdgeIt;
marci@317	1559	// typedef typename Graph::Edge GraphEdge;
marci@317	1560	// FlowMap* flow;
marci@317	1561	// const CapacityMap* capacity;
marci@317	1562	// public:
marci@317	1563
marci@317	1564	// ResGraphWrapper(Graph& _graph, FlowMap& _flow,
marci@317	1565	// const CapacityMap& _capacity) :
marci@317	1566	// GraphWrapper<Graph>(_graph), flow(&_flow), capacity(&_capacity) { }
marci@317	1567
marci@317	1568	// class Edge;
marci@317	1569	// class OutEdgeIt;
marci@317	1570	// friend class Edge;
marci@317	1571	// friend class OutEdgeIt;
marci@317	1572
marci@317	1573	// typedef typename GraphWrapper<Graph>::Node Node;
marci@317	1574	// typedef typename GraphWrapper<Graph>::NodeIt NodeIt;
marci@317	1575	// class Edge {
marci@317	1576	// friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1577	// protected:
marci@317	1578	// bool out_or_in; //true, iff out
marci@317	1579	// GraphOutEdgeIt out;
marci@317	1580	// GraphInEdgeIt in;
marci@317	1581	// public:
marci@317	1582	// Edge() : out_or_in(true) { }
marci@317	1583	// Edge(const Invalid& i) : out_or_in(false), out(), in(i) { }
marci@317	1584	// // bool valid() const {
marci@317	1585	// // return out_or_in && out.valid() \|\| in.valid(); }
marci@317	1586	// friend bool operator==(const Edge& u, const Edge& v) {
marci@317	1587	// if (v.out_or_in)
marci@317	1588	// return (u.out_or_in && u.out==v.out);
marci@317	1589	// else
marci@317	1590	// return (!u.out_or_in && u.in==v.in);
marci@317	1591	// }
marci@317	1592	// friend bool operator!=(const Edge& u, const Edge& v) {
marci@317	1593	// if (v.out_or_in)
marci@317	1594	// return (!u.out_or_in \|\| u.out!=v.out);
marci@317	1595	// else
marci@317	1596	// return (u.out_or_in \|\| u.in!=v.in);
marci@317	1597	// }
marci@317	1598	// operator GraphEdge() const {
marci@317	1599	// if (out_or_in) return(out); else return(in);
marci@317	1600	// }
marci@317	1601	// };
marci@317	1602	// class OutEdgeIt : public Edge {
marci@317	1603	// friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1604	// public:
marci@317	1605	// OutEdgeIt() { }
marci@317	1606	// //FIXME
marci@317	1607	// OutEdgeIt(const Edge& e) : Edge(e) { }
marci@317	1608	// OutEdgeIt(const Invalid& i) : Edge(i) { }
marci@317	1609	// OutEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, Node v) : Edge() {
marci@317	1610	// resG.graph->first(out, v);
marci@317	1611	// while( resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
marci@317	1612	// if (!resG.graph->valid(out)) {
marci@317	1613	// out_or_in=0;
marci@317	1614	// resG.graph->first(in, v);
marci@317	1615	// while( resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
marci@317	1616	// }
marci@317	1617	// }
marci@317	1618	// // public:
marci@317	1619	// // OutEdgeIt& operator++() {
marci@317	1620	// // if (out_or_in) {
marci@317	1621	// // Node v=/resG->/G->aNode(out);
marci@317	1622	// // ++out;
marci@317	1623	// // while( out.valid() && !(Edge::resCap()>0) ) { ++out; }
marci@317	1624	// // if (!out.valid()) {
marci@317	1625	// // out_or_in=0;
marci@317	1626	// // G->first(in, v);
marci@317	1627	// // while( in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@317	1628	// // }
marci@317	1629	// // } else {
marci@317	1630	// // ++in;
marci@317	1631	// // while( in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@317	1632	// // }
marci@317	1633	// // return *this;
marci@317	1634	// // }
marci@317	1635	// };
marci@317	1636
marci@317	1637	// //FIXME This is just for having InEdgeIt
marci@317	1638	// // class InEdgeIt : public Edge { };
marci@317	1639
marci@317	1640	// class EdgeIt : public Edge {
marci@317	1641	// friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;
marci@317	1642	// NodeIt v;
marci@317	1643	// public:
marci@317	1644	// EdgeIt() { }
marci@317	1645	// //EdgeIt(const EdgeIt& e) : Edge(e), v(e.v) { }
marci@317	1646	// EdgeIt(const Invalid& i) : Edge(i) { }
marci@317	1647	// EdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG) : Edge() {
marci@317	1648	// resG.graph->first(v);
marci@317	1649	// if (resG.graph->valid(v)) resG.graph->first(out, v); else out=INVALID;
marci@317	1650	// while (resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
marci@317	1651	// while (resG.graph->valid(v) && !resG.graph->valid(out)) {
marci@317	1652	// resG.graph->next(v);
marci@317	1653	// if (resG.graph->valid(v)) resG.graph->first(out, v);
marci@317	1654	// while (resG.graph->valid(out) && !(resG.resCap(out)>0) ) { resG.graph->next(out); }
marci@317	1655	// }
marci@317	1656	// if (!resG.graph->valid(out)) {
marci@317	1657	// out_or_in=0;
marci@317	1658	// resG.graph->first(v);
marci@317	1659	// if (resG.graph->valid(v)) resG.graph->first(in, v); else in=INVALID;
marci@317	1660	// while (resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
marci@317	1661	// while (resG.graph->valid(v) && !resG.graph->valid(in)) {
marci@317	1662	// resG.graph->next(v);
marci@317	1663	// if (resG.graph->valid(v)) resG.graph->first(in, v);
marci@317	1664	// while (resG.graph->valid(in) && !(resG.resCap(in)>0) ) { resG.graph->next(in); }
marci@317	1665	// }
marci@317	1666	// }
marci@317	1667	// }
marci@317	1668	// // EdgeIt& operator++() {
marci@317	1669	// // if (out_or_in) {
marci@317	1670	// // ++out;
marci@317	1671	// // while (out.valid() && !(Edge::resCap()>0) ) { ++out; }
marci@317	1672	// // while (v.valid() && !out.valid()) {
marci@317	1673	// // ++v;
marci@317	1674	// // if (v.valid()) G->first(out, v);
marci@317	1675	// // while (out.valid() && !(Edge::resCap()>0) ) { ++out; }
marci@317	1676	// // }
marci@317	1677	// // if (!out.valid()) {
marci@317	1678	// // out_or_in=0;
marci@317	1679	// // G->first(v);
marci@317	1680	// // if (v.valid()) G->first(in, v); else in=GraphInEdgeIt();
marci@317	1681	// // while (in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@317	1682	// // while (v.valid() && !in.valid()) {
marci@317	1683	// // ++v;
marci@317	1684	// // if (v.valid()) G->first(in, v);
marci@317	1685	// // while (in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@317	1686	// // }
marci@317	1687	// // }
marci@317	1688	// // } else {
marci@317	1689	// // ++in;
marci@317	1690	// // while (in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@317	1691	// // while (v.valid() && !in.valid()) {
marci@317	1692	// // ++v;
marci@317	1693	// // if (v.valid()) G->first(in, v);
marci@317	1694	// // while (in.valid() && !(Edge::resCap()>0) ) { ++in; }
marci@317	1695	// // }
marci@317	1696	// // }
marci@317	1697	// // return *this;
marci@317	1698	// // }
marci@317	1699	// };
marci@317	1700
marci@317	1701	// NodeIt& first(NodeIt& i) const {
marci@317	1702	// i=NodeIt(*this);
marci@317	1703	// return i;
marci@317	1704	// }
marci@317	1705	// OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
marci@317	1706	// i=OutEdgeIt(*this, p);
marci@317	1707	// return i;
marci@317	1708	// }
marci@317	1709	// //FIXME Not yet implemented
marci@317	1710	// //InEdgeIt& first(InEdgeIt& i, const Node& p) const {
marci@317	1711	// //i=InEdgeIt(*this, p);
marci@317	1712	// // return i;
marci@317	1713	// //}
marci@317	1714	// EdgeIt& first(EdgeIt& e) const {
marci@317	1715	// e=EdgeIt(*this);
marci@317	1716	// return e;
marci@317	1717	// }
marci@317	1718
marci@317	1719	// NodeIt& next(NodeIt& n) const { graph->next(n); return n; }
marci@317	1720	// OutEdgeIt& next(OutEdgeIt& e) const {
marci@317	1721	// if (e.out_or_in) {
marci@317	1722	// Node v=graph->aNode(e.out);
marci@317	1723	// graph->next(e.out);
marci@317	1724	// while( graph->valid(e.out) && !(resCap(e.out)>0) ) { graph->next(e.out); }
marci@317	1725	// if (!graph->valid(e.out)) {
marci@317	1726	// e.out_or_in=0;
marci@317	1727	// graph->first(e.in, v);
marci@317	1728	// while( graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1729	// }
marci@317	1730	// } else {
marci@317	1731	// graph->next(e.in);
marci@317	1732	// while( graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1733	// }
marci@317	1734	// return e;
marci@317	1735	// }
marci@317	1736	// //FIXME Not yet implemented
marci@317	1737	// //InEdgeIt& next(InEdgeIt& e) const {
marci@317	1738	// // return e;
marci@317	1739	// //}
marci@317	1740	// EdgeIt& next(EdgeIt& e) const {
marci@317	1741	// if (e.out_or_in) {
marci@317	1742	// graph->next(e.out);
marci@317	1743	// while (graph->valid(e.out) && !(resCap(e.out)>0) ) { graph->next(e.out); }
marci@317	1744	// while (graph->valid(e.v) && !graph->valid(e.out)) {
marci@317	1745	// graph->next(e.v);
marci@317	1746	// if (graph->valid(e.v)) graph->first(e.out, e.v);
marci@317	1747	// while (graph->valid(e.out) && !(resCap(e.out)>0) ) { graph->next(e.out); }
marci@317	1748	// }
marci@317	1749	// if (!graph->valid(e.out)) {
marci@317	1750	// e.out_or_in=0;
marci@317	1751	// graph->first(e.v);
marci@317	1752	// if (graph->valid(e.v)) graph->first(e.in, e.v); else e.in=INVALID;
marci@317	1753	// while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1754	// while (graph->valid(e.v) && !graph->valid(e.in)) {
marci@317	1755	// graph->next(e.v);
marci@317	1756	// if (graph->valid(e.v)) graph->first(e.in, e.v);
marci@317	1757	// while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1758	// }
marci@317	1759	// }
marci@317	1760	// } else {
marci@317	1761	// graph->next(e.in);
marci@317	1762	// while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1763	// while (graph->valid(e.v) && !graph->valid(e.in)) {
marci@317	1764	// graph->next(e.v);
marci@317	1765	// if (graph->valid(e.v)) graph->first(e.in, e.v);
marci@317	1766	// while (graph->valid(e.in) && !(resCap(e.in)>0) ) { graph->next(e.in); }
marci@317	1767	// }
marci@317	1768	// }
marci@317	1769	// return e;
marci@317	1770	// }
marci@317	1771
marci@317	1772
marci@317	1773	// template< typename It >
marci@317	1774	// It first() const {
marci@317	1775	// It e;
marci@317	1776	// first(e);
marci@317	1777	// return e;
marci@317	1778	// }
marci@317	1779
marci@317	1780	// template< typename It >
marci@317	1781	// It first(Node v) const {
marci@317	1782	// It e;
marci@317	1783	// first(e, v);
marci@317	1784	// return e;
marci@317	1785	// }
marci@317	1786
marci@317	1787	// Node tail(Edge e) const {
marci@317	1788	// return ((e.out_or_in) ? graph->aNode(e.out) : graph->aNode(e.in)); }
marci@317	1789	// Node head(Edge e) const {
marci@317	1790	// return ((e.out_or_in) ? graph->bNode(e.out) : graph->bNode(e.in)); }
marci@317	1791
marci@317	1792	// Node aNode(OutEdgeIt e) const {
marci@317	1793	// return ((e.out_or_in) ? graph->aNode(e.out) : graph->aNode(e.in)); }
marci@317	1794	// Node bNode(OutEdgeIt e) const {
marci@317	1795	// return ((e.out_or_in) ? graph->bNode(e.out) : graph->bNode(e.in)); }
marci@317	1796
marci@317	1797	// int nodeNum() const { return graph->nodeNum(); }
marci@317	1798	// //FIXME
marci@317	1799	// //int edgeNum() const { return graph->edgeNum(); }
marci@317	1800
marci@317	1801
marci@317	1802	// int id(Node v) const { return graph->id(v); }
marci@317	1803
marci@317	1804	// bool valid(Node n) const { return graph->valid(n); }
marci@317	1805	// bool valid(Edge e) const {
marci@317	1806	// return e.out_or_in ? graph->valid(e.out) : graph->valid(e.in); }
marci@317	1807
marci@317	1808	// void augment(const Edge& e, Number a) const {
marci@317	1809	// if (e.out_or_in)
marci@317	1810	// // flow->set(e.out, flow->get(e.out)+a);
marci@317	1811	// flow->set(e.out, (*flow)[e.out]+a);
marci@317	1812	// else
marci@317	1813	// // flow->set(e.in, flow->get(e.in)-a);
marci@317	1814	// flow->set(e.in, (*flow)[e.in]-a);
marci@317	1815	// }
marci@317	1816
marci@317	1817	// Number resCap(const Edge& e) const {
marci@317	1818	// if (e.out_or_in)
marci@317	1819	// // return (capacity->get(e.out)-flow->get(e.out));
marci@317	1820	// return ((capacity)[e.out]-(flow)[e.out]);
marci@317	1821	// else
marci@317	1822	// // return (flow->get(e.in));
marci@317	1823	// return ((*flow)[e.in]);
marci@317	1824	// }
marci@317	1825
marci@317	1826	// Number resCap(GraphOutEdgeIt out) const {
marci@317	1827	// // return (capacity->get(out)-flow->get(out));
marci@317	1828	// return ((capacity)[out]-(flow)[out]);
marci@317	1829	// }
marci@317	1830
marci@317	1831	// Number resCap(GraphInEdgeIt in) const {
marci@317	1832	// // return (flow->get(in));
marci@317	1833	// return ((*flow)[in]);
marci@317	1834	// }
marci@317	1835
marci@317	1836	// // template<typename T> class NodeMap : public Graph::NodeMap<T> {
marci@317	1837	// // public:
marci@317	1838	// // NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G)
marci@317	1839	// // : Graph::NodeMap<T>(_G.gw) { }
marci@317	1840	// // NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G,
marci@317	1841	// // T a) : Graph::NodeMap<T>(_G.gw, a) { }
marci@317	1842	// // };
marci@317	1843
marci@317	1844	// // template <typename T>
marci@317	1845	// // class NodeMap {
marci@317	1846	// // typename Graph::NodeMap<T> node_map;
marci@317	1847	// // public:
marci@317	1848	// // NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : node_map(*(_G.graph)) { }
marci@317	1849	// // NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : node_map(*(_G.graph), a) { }
marci@317	1850	// // void set(Node nit, T a) { node_map.set(nit, a); }
marci@317	1851	// // T get(Node nit) const { return node_map.get(nit); }
marci@317	1852	// // };
marci@317	1853
marci@317	1854	// template <typename T>
marci@317	1855	// class EdgeMap {
marci@317	1856	// typename Graph::EdgeMap<T> forward_map, backward_map;
marci@317	1857	// public:
marci@317	1858	// EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : forward_map((_G.graph)), backward_map((_G.graph)) { }
marci@317	1859	// EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : forward_map((_G.graph), a), backward_map((_G.graph), a) { }
marci@317	1860	// void set(Edge e, T a) {
marci@317	1861	// if (e.out_or_in)
marci@317	1862	// forward_map.set(e.out, a);
marci@317	1863	// else
marci@317	1864	// backward_map.set(e.in, a);
marci@317	1865	// }
marci@317	1866	// T operator[](Edge e) const {
marci@317	1867	// if (e.out_or_in)
marci@317	1868	// return forward_map[e.out];
marci@317	1869	// else
marci@317	1870	// return backward_map[e.in];
marci@317	1871	// }
marci@317	1872	// // T get(Edge e) const {
marci@317	1873	// // if (e.out_or_in)
marci@317	1874	// // return forward_map.get(e.out);
marci@317	1875	// // else
marci@317	1876	// // return backward_map.get(e.in);
marci@317	1877	// // }
marci@317	1878	// };
marci@317	1879	// };
marci@317	1880
marci@317	1881
marci@303	1882	//ErasingFirstGraphWrapper for blocking flows
marci@303	1883	template<typename Graph, typename FirstOutEdgesMap>
marci@303	1884	class ErasingFirstGraphWrapper : public GraphWrapper<Graph> {
marci@269	1885	protected:
marci@269	1886	FirstOutEdgesMap* first_out_edges;
marci@269	1887	public:
marci@303	1888	ErasingFirstGraphWrapper(Graph& _graph,
marci@303	1889	FirstOutEdgesMap& _first_out_edges) :
marci@303	1890	GraphWrapper<Graph>(_graph), first_out_edges(&_first_out_edges) { }
marci@269	1891
marci@317	1892	typedef typename GraphWrapper<Graph>::Node Node;
marci@317	1893	class NodeIt {
marci@317	1894	friend class GraphWrapper<Graph>;
marci@317	1895	friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
marci@317	1896	typename Graph::NodeIt n;
marci@317	1897	public:
marci@311	1898	NodeIt() { }
marci@317	1899	NodeIt(const typename Graph::NodeIt& _n) : n(_n) { }
marci@317	1900	NodeIt(const Invalid& i) : n(i) { }
marci@311	1901	NodeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) :
marci@317	1902	n(*(_G.graph)) { }
marci@317	1903	operator Node() const { return Node(typename Graph::Node(n)); }
marci@311	1904	};
marci@317	1905	typedef typename GraphWrapper<Graph>::Edge Edge;
marci@317	1906	class OutEdgeIt {
marci@317	1907	friend class GraphWrapper<Graph>;
marci@317	1908	friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
marci@317	1909	// typedef typename Graph::OutEdgeIt GraphOutEdgeIt;
marci@317	1910	typename Graph::OutEdgeIt e;
marci@311	1911	public:
marci@311	1912	OutEdgeIt() { }
marci@317	1913	OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }
marci@317	1914	OutEdgeIt(const Invalid& i) : e(i) { }
marci@311	1915	OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G,
marci@317	1916	const Node& _n) :
marci@317	1917	e((*_G.first_out_edges)[_n]) { }
marci@317	1918	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@311	1919	};
marci@317	1920	class InEdgeIt {
marci@317	1921	friend class GraphWrapper<Graph>;
marci@317	1922	friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
marci@317	1923	// typedef typename Graph::InEdgeIt GraphInEdgeIt;
marci@317	1924	typename Graph::InEdgeIt e;
marci@311	1925	public:
marci@311	1926	InEdgeIt() { }
marci@317	1927	InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
marci@317	1928	InEdgeIt(const Invalid& i) : e(i) { }
marci@311	1929	InEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G,
marci@317	1930	const Node& _n) :
marci@317	1931	e(*(_G.graph), typename Graph::Node(_n)) { }
marci@317	1932	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@311	1933	};
marci@311	1934	//typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@317	1935	class EdgeIt {
marci@317	1936	friend class GraphWrapper<Graph>;
marci@317	1937	friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;
marci@317	1938	// typedef typename Graph::EdgeIt GraphEdgeIt;
marci@317	1939	typename Graph::EdgeIt e;
marci@311	1940	public:
marci@311	1941	EdgeIt() { }
marci@317	1942	EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
marci@317	1943	EdgeIt(const Invalid& i) : e(i) { }
marci@311	1944	EdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) :
marci@317	1945	e(*(_G.graph)) { }
marci@317	1946	operator Edge() const { return Edge(typename Graph::Edge(e)); }
marci@311	1947	};
marci@311	1948
marci@317	1949	NodeIt& first(NodeIt& i) const {
marci@317	1950	i=NodeIt(*this); return i;
marci@269	1951	}
marci@317	1952	OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
marci@317	1953	i=OutEdgeIt(*this, p); return i;
marci@269	1954	}
marci@317	1955	InEdgeIt& first(InEdgeIt& i, const Node& p) const {
marci@317	1956	i=InEdgeIt(*this, p); return i;
marci@311	1957	}
marci@317	1958	EdgeIt& first(EdgeIt& i) const {
marci@317	1959	i=EdgeIt(*this); return i;
marci@311	1960	}
marci@311	1961
marci@311	1962	// template<typename I> I& first(I& i) const {
marci@311	1963	// graph->first(i);
marci@311	1964	// return i;
marci@311	1965	// }
marci@311	1966	// OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
marci@311	1967	// // e=first_out_edges->get(n);
marci@311	1968	// e=(*first_out_edges)[n];
marci@311	1969	// return e;
marci@311	1970	// }
marci@311	1971	// template<typename I, typename P> I& first(I& i, const P& p) const {
marci@311	1972	// graph->first(i, p);
marci@311	1973	// return i;
marci@311	1974	// }
marci@269	1975
marci@269	1976	//template<typename I> I getNext(const I& i) const {
marci@269	1977	// return gw.getNext(i);
marci@269	1978	//}
marci@311	1979
marci@311	1980
marci@317	1981	NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
marci@317	1982	OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i.e); return i; }
marci@317	1983	InEdgeIt& next(InEdgeIt& i) const { graph->next(i.e); return i; }
marci@317	1984	EdgeIt& next(EdgeIt& i) const { graph->next(i.e); return i; }
marci@317	1985
marci@317	1986	Node aNode(const OutEdgeIt& e) const { return Node(graph->aNode(e.e)); }
marci@317	1987	Node aNode(const InEdgeIt& e) const { return Node(graph->aNode(e.e)); }
marci@317	1988	Node bNode(const OutEdgeIt& e) const { return Node(graph->bNode(e.e)); }
marci@317	1989	Node bNode(const InEdgeIt& e) const { return Node(graph->bNode(e.e)); }
marci@311	1990
marci@311	1991	// template<typename I> I& next(I &i) const {
marci@311	1992	// graph->next(i);
marci@311	1993	// return i;
marci@311	1994	// }
marci@269	1995
marci@269	1996	template< typename It > It first() const {
marci@269	1997	It e; this->first(e); return e; }
marci@269	1998
marci@269	1999	template< typename It > It first(const Node& v) const {
marci@269	2000	It e; this->first(e, v); return e; }
marci@269	2001
marci@269	2002	void erase(const OutEdgeIt& e) const {
marci@269	2003	OutEdgeIt f=e;
marci@269	2004	this->next(f);
marci@317	2005	first_out_edges->set(this->tail(e), f.e);
marci@269	2006	}
marci@269	2007	};
marci@269	2008
marci@317	2009	// //ErasingFirstGraphWrapper for blocking flows
marci@317	2010	// template<typename Graph, typename FirstOutEdgesMap>
marci@317	2011	// class ErasingFirstGraphWrapper : public GraphWrapper<Graph> {
marci@317	2012	// protected:
marci@317	2013	// FirstOutEdgesMap* first_out_edges;
marci@317	2014	// public:
marci@317	2015	// ErasingFirstGraphWrapper(Graph& _graph,
marci@317	2016	// FirstOutEdgesMap& _first_out_edges) :
marci@317	2017	// GraphWrapper<Graph>(_graph), first_out_edges(&_first_out_edges) { }
marci@317	2018
marci@317	2019	// typedef typename Graph::Node Node;
marci@317	2020	// class NodeIt : public Graph::NodeIt {
marci@317	2021	// public:
marci@317	2022	// NodeIt() { }
marci@317	2023	// NodeIt(const typename Graph::NodeIt& n) : Graph::NodeIt(n) { }
marci@317	2024	// NodeIt(const Invalid& i) : Graph::NodeIt(i) { }
marci@317	2025	// NodeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) :
marci@317	2026	// Graph::NodeIt(*(_G.graph)) { }
marci@317	2027	// };
marci@317	2028	// typedef typename Graph::Edge Edge;
marci@317	2029	// class OutEdgeIt : public Graph::OutEdgeIt {
marci@317	2030	// public:
marci@317	2031	// OutEdgeIt() { }
marci@317	2032	// OutEdgeIt(const typename Graph::OutEdgeIt& e) : Graph::OutEdgeIt(e) { }
marci@317	2033	// OutEdgeIt(const Invalid& i) : Graph::OutEdgeIt(i) { }
marci@317	2034	// OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G,
marci@317	2035	// const Node& n) :
marci@317	2036	// Graph::OutEdgeIt((*_G.first_out_edges)[n]) { }
marci@317	2037	// };
marci@317	2038	// class InEdgeIt : public Graph::InEdgeIt {
marci@317	2039	// public:
marci@317	2040	// InEdgeIt() { }
marci@317	2041	// InEdgeIt(const typename Graph::InEdgeIt& e) : Graph::InEdgeIt(e) { }
marci@317	2042	// InEdgeIt(const Invalid& i) : Graph::InEdgeIt(i) { }
marci@317	2043	// InEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G,
marci@317	2044	// const Node& n) :
marci@317	2045	// Graph::InEdgeIt(*(_G.graph), n) { }
marci@317	2046	// };
marci@317	2047	// //typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@317	2048	// class EdgeIt : public Graph::EdgeIt {
marci@317	2049	// public:
marci@317	2050	// EdgeIt() { }
marci@317	2051	// EdgeIt(const typename Graph::EdgeIt& e) : Graph::EdgeIt(e) { }
marci@317	2052	// EdgeIt(const Invalid& i) : Graph::EdgeIt(i) { }
marci@317	2053	// EdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) :
marci@317	2054	// Graph::EdgeIt(*(_G.graph)) { }
marci@317	2055	// };
marci@317	2056
marci@317	2057	// NodeIt& first(NodeIt& i) const {
marci@317	2058	// i=NodeIt(*this);
marci@317	2059	// return i;
marci@317	2060	// }
marci@317	2061	// OutEdgeIt& first(OutEdgeIt& i, const Node& n) const {
marci@317	2062	// i=OutEdgeIt(*this, n);
marci@317	2063	// // i=(*first_out_edges)[n];
marci@317	2064	// return i;
marci@317	2065	// }
marci@317	2066	// InEdgeIt& first(InEdgeIt& i, const Node& n) const {
marci@317	2067	// i=InEdgeIt(*this, n);
marci@317	2068	// return i;
marci@317	2069	// }
marci@317	2070	// EdgeIt& first(EdgeIt& i) const {
marci@317	2071	// i=EdgeIt(*this);
marci@317	2072	// return i;
marci@317	2073	// }
marci@317	2074
marci@317	2075	// // template<typename I> I& first(I& i) const {
marci@317	2076	// // graph->first(i);
marci@317	2077	// // return i;
marci@317	2078	// // }
marci@317	2079	// // OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
marci@317	2080	// // // e=first_out_edges->get(n);
marci@317	2081	// // e=(*first_out_edges)[n];
marci@317	2082	// // return e;
marci@317	2083	// // }
marci@317	2084	// // template<typename I, typename P> I& first(I& i, const P& p) const {
marci@317	2085	// // graph->first(i, p);
marci@317	2086	// // return i;
marci@317	2087	// // }
marci@317	2088
marci@317	2089	// //template<typename I> I getNext(const I& i) const {
marci@317	2090	// // return gw.getNext(i);
marci@317	2091	// //}
marci@317	2092
marci@317	2093
marci@317	2094	// NodeIt& next(NodeIt& i) const {
marci@317	2095	// graph->next(i);
marci@317	2096	// return i;
marci@317	2097	// }
marci@317	2098	// OutEdgeIt& next(OutEdgeIt& i) const {
marci@317	2099	// graph->next(i);
marci@317	2100	// return i;
marci@317	2101	// }
marci@317	2102	// InEdgeIt& next(InEdgeIt& i) const {
marci@317	2103	// graph->next(i);
marci@317	2104	// return i;
marci@317	2105	// }
marci@317	2106	// EdgeIt& next(EdgeIt& i) const {
marci@317	2107	// graph->next(i);
marci@317	2108	// return i;
marci@317	2109	// }
marci@317	2110
marci@317	2111	// // template<typename I> I& next(I &i) const {
marci@317	2112	// // graph->next(i);
marci@317	2113	// // return i;
marci@317	2114	// // }
marci@317	2115
marci@317	2116	// template< typename It > It first() const {
marci@317	2117	// It e; this->first(e); return e; }
marci@317	2118
marci@317	2119	// template< typename It > It first(const Node& v) const {
marci@317	2120	// It e; this->first(e, v); return e; }
marci@317	2121
marci@317	2122	// void erase(const OutEdgeIt& e) const {
marci@317	2123	// OutEdgeIt f=e;
marci@317	2124	// this->next(f);
marci@317	2125	// first_out_edges->set(this->tail(e), f);
marci@317	2126	// }
marci@317	2127	// };
marci@317	2128
marci@317	2129
marci@148	2130	// // FIXME: comparison should be made better!!!
marci@148	2131	// template<typename Graph, typename T, typename LowerMap, typename FlowMap, typename UpperMap>
marci@148	2132	// class ResGraphWrapper
marci@148	2133	// {
marci@148	2134	// Graph* graph;
marci@76	2135
marci@148	2136	// public:
marci@303	2137	// typedef Graph ParentGraph;
marci@76	2138
marci@174	2139	// typedef typename Graph::Node Node;
marci@174	2140	// typedef typename Graph::Edge Edge;
marci@174	2141
marci@148	2142	// typedef typename Graph::NodeIt NodeIt;
marci@76	2143
marci@148	2144	// class OutEdgeIt {
marci@148	2145	// public:
marci@174	2146	// //Graph::Node n;
marci@148	2147	// bool out_or_in;
marci@148	2148	// typename Graph::OutEdgeIt o;
marci@148	2149	// typename Graph::InEdgeIt i;
marci@148	2150	// };
marci@148	2151	// class InEdgeIt {
marci@148	2152	// public:
marci@174	2153	// //Graph::Node n;
marci@148	2154	// bool out_or_in;
marci@148	2155	// typename Graph::OutEdgeIt o;
marci@148	2156	// typename Graph::InEdgeIt i;
marci@148	2157	// };
marci@148	2158	// typedef typename Graph::SymEdgeIt SymEdgeIt;
marci@174	2159	// typedef typename Graph::EdgeIt EdgeIt;
marci@76	2160
marci@259	2161	// int nodeNum() const { return gw.nodeNum(); }
marci@259	2162	// int edgeNum() const { return gw.edgeNum(); }
marci@76	2163
marci@259	2164	// Node& first(Node& n) const { return gw.first(n); }
marci@76	2165
marci@174	2166	// // Edge and SymEdge is missing!!!!
marci@174	2167	// // Edge <-> In/OutEdgeIt conversion is missing!!!!
marci@76	2168
marci@148	2169	// //FIXME
marci@212	2170	// OutEdgeIt& first(OutEdgeIt& e, const Node& n) const
marci@148	2171	// {
marci@148	2172	// e.n=n;
marci@259	2173	// gw.first(e.o,n);
marci@259	2174	// while(gw.valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
marci@259	2175	// gw.goNext(e.o);
marci@259	2176	// if(!gw.valid(e.o)) {
marci@259	2177	// gw.first(e.i,n);
marci@259	2178	// while(gw.valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
marci@259	2179	// gw.goNext(e.i);
marci@148	2180	// }
marci@148	2181	// return e;
marci@148	2182	// }
marci@148	2183	// /*
marci@148	2184	// OutEdgeIt &goNext(OutEdgeIt &e)
marci@148	2185	// {
marci@259	2186	// if(gw.valid(e.o)) {
marci@259	2187	// while(gw.valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
marci@259	2188	// gw.goNext(e.o);
marci@259	2189	// if(gw.valid(e.o)) return e;
marci@259	2190	// else gw.first(e.i,e.n);
marci@148	2191	// }
marci@148	2192	// else {
marci@259	2193	// while(gw.valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
marci@259	2194	// gw.goNext(e.i);
marci@148	2195	// return e;
marci@148	2196	// }
marci@148	2197	// }
marci@148	2198	// OutEdgeIt Next(const OutEdgeIt &e) {OutEdgeIt t(e); return goNext(t);}
marci@148	2199	// */
marci@259	2200	// //bool valid(const OutEdgeIt e) { return gw.valid(e.o)\|\|gw.valid(e.i);}
marci@76	2201
marci@148	2202	// //FIXME
marci@212	2203	// InEdgeIt& first(InEdgeIt& e, const Node& n) const
marci@148	2204	// {
marci@148	2205	// e.n=n;
marci@259	2206	// gw.first(e.i,n);
marci@259	2207	// while(gw.valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
marci@259	2208	// gw.goNext(e.i);
marci@259	2209	// if(!gw.valid(e.i)) {
marci@259	2210	// gw.first(e.o,n);
marci@259	2211	// while(gw.valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
marci@259	2212	// gw.goNext(e.o);
marci@148	2213	// }
marci@148	2214	// return e;
marci@148	2215	// }
marci@148	2216	// /*
marci@148	2217	// InEdgeIt &goNext(InEdgeIt &e)
marci@148	2218	// {
marci@259	2219	// if(gw.valid(e.i)) {
marci@259	2220	// while(gw.valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
marci@259	2221	// gw.goNext(e.i);
marci@259	2222	// if(gw.valid(e.i)) return e;
marci@259	2223	// else gw.first(e.o,e.n);
marci@148	2224	// }
marci@148	2225	// else {
marci@259	2226	// while(gw.valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
marci@259	2227	// gw.goNext(e.o);
marci@148	2228	// return e;
marci@148	2229	// }
marci@148	2230	// }
marci@148	2231	// InEdgeIt Next(const InEdgeIt &e) {InEdgeIt t(e); return goNext(t);}
marci@148	2232	// */
marci@259	2233	// //bool valid(const InEdgeIt e) { return gw.valid(e.i)\|\|gw.valid(e.o);}
marci@76	2234
marci@259	2235	// //template<typename I> I &goNext(I &i); { return gw.goNext(i); }
marci@259	2236	// //template<typename I> I next(const I i); { return gw.goNext(i); }
marci@76	2237
marci@148	2238	// template< typename It > It first() const {
marci@212	2239	// It e; first(e); return e; }
marci@76	2240
marci@174	2241	// template< typename It > It first(Node v) const {
marci@212	2242	// It e; first(e, v); return e; }
marci@76	2243
marci@259	2244	// Node head(const Edge& e) const { return gw.head(e); }
marci@259	2245	// Node tail(const Edge& e) const { return gw.tail(e); }
marci@76	2246
marci@174	2247	// template<typename I> Node aNode(const I& e) const {
marci@259	2248	// return gw.aNode(e); }
marci@174	2249	// template<typename I> Node bNode(const I& e) const {
marci@259	2250	// return gw.bNode(e); }
marci@76	2251
marci@148	2252	// //template<typename I> bool valid(const I i);
marci@259	2253	// //{ return gw.valid(i); }
marci@76	2254
marci@148	2255	// //template<typename I> void setInvalid(const I &i);
marci@259	2256	// //{ return gw.setInvalid(i); }
marci@76	2257
marci@259	2258	// Node addNode() { return gw.addNode(); }
marci@174	2259	// Edge addEdge(const Node& tail, const Node& head) {
marci@259	2260	// return gw.addEdge(tail, head); }
marci@76	2261
marci@259	2262	// template<typename I> void erase(const I& i) { gw.erase(i); }
marci@76	2263
marci@259	2264	// void clear() { gw.clear(); }
marci@76	2265
marci@148	2266	// template<typename S> class NodeMap : public Graph::NodeMap<S> { };
marci@148	2267	// template<typename S> class EdgeMap : public Graph::EdgeMap<S> { };
marci@76	2268
marci@148	2269	// void setGraph(Graph& _graph) { graph = &_graph; }
marci@148	2270	// Graph& getGraph() { return (*graph); }
marci@76	2271
marci@148	2272	// //ResGraphWrapper() : graph(0) { }
marci@148	2273	// ResGraphWrapper(Graph& _graph) : graph(&_graph) { }
marci@148	2274	// };
marci@76	2275
alpar@105	2276	} //namespace hugo
marci@76	2277
marci@259	2278	#endif //HUGO_GRAPH_WRAPPER_H
marci@76	2279

author	marci
	Tue, 13 Apr 2004 20:35:47 +0000
changeset 317	6e6db1c49bc1
parent 312	54e07057eb47
child 318	7bec4e8fb7dd
permissions	-rw-r--r--