[Lemon-commits] [lemon_svn] marci: r460 - hugo/trunk/src/work/marci
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:39:34 CET 2006
Author: marci
Date: Fri Apr 16 19:39:19 2004
New Revision: 460
Modified:
hugo/trunk/src/work/marci/graph_wrapper.h
Log:
semmi
Modified: hugo/trunk/src/work/marci/graph_wrapper.h
==============================================================================
--- hugo/trunk/src/work/marci/graph_wrapper.h (original)
+++ hugo/trunk/src/work/marci/graph_wrapper.h Fri Apr 16 19:39:19 2004
@@ -852,6 +852,185 @@
}
};
+
+
+// /// experimentral, do not try it.
+// template<typename Graph>
+// class stGraphWrapper : public GraphWrapper<Graph> {
+// public:
+// class Node;
+// class NodeIt;
+// class Edge;
+// class OutEdgeIt;
+// class InEdgeIt;
+// class EdgeIt;
+
+// const Node s;
+// const Node t;
+
+// stGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph),
+// s(INVALID, 1), t(INVALID, 2) { }
+
+// class Node : public Graph::Node {
+// friend class GraphWrapper<Graph>;
+// friend class stGraphWrapper<Graph>;
+// protected:
+// int spec; //0 if real node, 1 iff s, 2 iff t
+// public:
+// Node() { }
+// Node(const typename Graph::Node& _n, int _spec=0) :
+// Graph::Node(_n), spec(_spec) { }
+// Node(const Invalid& i) : Graph::Node(i), spec(2) { }
+// //invalid: (invalid, 2);
+// };
+
+// class NodeIt {
+// friend class GraphWrapper<Graph>;
+// friend class stGraphWrapper<Graph>;
+// typename Graph::NodeIt n;
+// int spec;
+// public:
+// NodeIt() { }
+// NodeIt(const typename Graph::NodeIt& _n, int _spec=0) :
+// n(_n), spec(_spec) { }
+// NodeIt(const Invalid& i) : n(i), spec(2) { }
+// NodeIt(const GraphWrapper<Graph>& _G) : n(*(_G.graph)), spec(0) {
+// if (!_G->valid(n)) spec=1;
+// }
+// operator Node() const { return Node(n, spec); }
+// };
+// // typedef typename Graph::Edge Edge;
+// class Edge : public Graph::Edge {
+// friend class GraphWrapper<Graph>;
+// friend class stGraphWrapper<Graph>;
+// Node tail_spec;
+// Node head_spec;
+// public:
+// Edge() { }
+// Edge(const typename Graph::Edge& _e) :
+// Graph::Edge(_e), tail_spec(i, 0), head_spec(i, 0) {
+// //a tail-t es a head-et real node-ra csinaljuk
+// }
+// Edge(const Invalid& i) : Graph::Edge(i), tail_spec(i), head_spec(i) { }
+// };
+// class OutEdgeIt {
+// friend class GraphWrapper<Graph>;
+// friend class stGraphWrapper<Graph>;
+// typename Graph::OutEdgeIt e;
+// Node tail_spec;
+// Node head_spec;
+// public:
+// OutEdgeIt() { }
+// OutEdgeIt(const typename Graph::OutEdgeIt& _e) :
+// e(_e), tail_spec(i, 0), head_spec(i, 0) {
+// //a tail-t es a head-et real node-ra csinaljuk
+// }
+// OutEdgeIt(const Invalid& i) : e(i), tail_spec(i), head_spec(i) { }
+// //invalid: (barmi, 0, 2)
+// OutEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) {
+// switch (_n.spec) {
+// case 0 :
+// e=typename Graph::OutEdgeIt(*(_G.graph), typename Graph::Node(_n));
+// _tail.spec=0;
+// _head.spec=0;
+// if (!_G.graph->valid(e)) spec=1;
+// break;
+// case 1:
+// e=INVALID;
+// _tail.spec=1;
+// _head(_G.graph->first(typename Graph::NodeIt()));
+// if _head.spec==1
+// break;
+// };
+
+// }
+// operator Edge() const { return Edge(typename Graph::Edge(e)); }
+// };
+// class InEdgeIt {
+// friend class GraphWrapper<Graph>;
+// typename Graph::InEdgeIt e;
+// public:
+// InEdgeIt() { }
+// InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }
+// InEdgeIt(const Invalid& i) : e(i) { }
+// InEdgeIt(const GraphWrapper<Graph>& _G, const Node& _n) :
+// e(*(_G.graph), typename Graph::Node(_n)) { }
+// operator Edge() const { return Edge(typename Graph::Edge(e)); }
+// };
+// //typedef typename Graph::SymEdgeIt SymEdgeIt;
+// class EdgeIt {
+// friend class GraphWrapper<Graph>;
+// typename Graph::EdgeIt e;
+// public:
+// EdgeIt() { }
+// EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }
+// EdgeIt(const Invalid& i) : e(i) { }
+// EdgeIt(const GraphWrapper<Graph>& _G) : e(*(_G.graph)) { }
+// operator Edge() const { return Edge(typename Graph::Edge(e)); }
+// };
+
+// NodeIt& first(NodeIt& i) const {
+// i=NodeIt(*this); return i;
+// }
+// OutEdgeIt& first(OutEdgeIt& i, const Node& p) const {
+// i=OutEdgeIt(*this, p); return i;
+// }
+// InEdgeIt& first(InEdgeIt& i, const Node& p) const {
+// i=InEdgeIt(*this, p); return i;
+// }
+// EdgeIt& first(EdgeIt& i) const {
+// i=EdgeIt(*this); return i;
+// }
+
+// NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }
+// OutEdgeIt& next(OutEdgeIt& i) const { graph->next(i.e); return i; }
+// InEdgeIt& next(InEdgeIt& i) const { graph->next(i.e); return i; }
+// EdgeIt& next(EdgeIt& i) const { graph->next(i.e); return i; }
+
+// Node head(const Edge& e) const {
+// return Node(graph->head(static_cast<typename Graph::Edge>(e))); }
+// Node tail(const Edge& e) const {
+// return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
+
+// bool valid(const Node& n) const {
+// return graph->valid(static_cast<typename Graph::Node>(n)); }
+// bool valid(const Edge& e) const {
+// return graph->valid(static_cast<typename Graph::Edge>(e)); }
+
+// int nodeNum() const { return graph->nodeNum(); }
+// int edgeNum() const { return graph->edgeNum(); }
+
+// Node aNode(const OutEdgeIt& e) const { return Node(graph->aNode(e.e)); }
+// Node aNode(const InEdgeIt& e) const { return Node(graph->aNode(e.e)); }
+// Node bNode(const OutEdgeIt& e) const { return Node(graph->bNode(e.e)); }
+// Node bNode(const InEdgeIt& e) const { return Node(graph->bNode(e.e)); }
+
+// Node addNode() const { return Node(graph->addNode()); }
+// Edge addEdge(const Node& tail, const Node& head) const {
+// return Edge(graph->addEdge(tail, head)); }
+
+// void erase(const Node& i) const { graph->erase(i); }
+// void erase(const Edge& i) const { graph->erase(i); }
+
+// void clear() const { graph->clear(); }
+
+// template<typename T> class NodeMap : public Graph::NodeMap<T> {
+// public:
+// NodeMap(const GraphWrapper<Graph>& _G) :
+// Graph::NodeMap<T>(*(_G.graph)) { }
+// NodeMap(const GraphWrapper<Graph>& _G, T a) :
+// Graph::NodeMap<T>(*(_G.graph), a) { }
+// };
+
+// template<typename T> class EdgeMap : public Graph::EdgeMap<T> {
+// public:
+// EdgeMap(const GraphWrapper<Graph>& _G) :
+// Graph::EdgeMap<T>(*(_G.graph)) { }
+// EdgeMap(const GraphWrapper<Graph>& _G, T a) :
+// Graph::EdgeMap<T>(*(_G.graph), a) { }
+// };
+// };
+
} //namespace hugo
#endif //HUGO_GRAPH_WRAPPER_H
More information about the Lemon-commits
mailing list