[Lemon-commits] [lemon_svn] marci: r1398 - hugo/trunk/src/work/marci
Lemon SVN
svn at lemon.cs.elte.hu
Mon Nov 6 20:45:06 CET 2006
Author: marci
Date: Thu Nov 18 23:31:21 2004
New Revision: 1398
Modified:
hugo/trunk/src/work/marci/merge_node_graph_wrapper.h
hugo/trunk/src/work/marci/merge_node_graph_wrapper_test.cc
Log:
RoadMap to MergeGraphWrapper and STGraphWrapper,
NewEdgeSetGraphWrapper which is similar to the old EdgeSet
Modified: hugo/trunk/src/work/marci/merge_node_graph_wrapper.h
==============================================================================
--- hugo/trunk/src/work/marci/merge_node_graph_wrapper.h (original)
+++ hugo/trunk/src/work/marci/merge_node_graph_wrapper.h Thu Nov 18 23:31:21 2004
@@ -22,6 +22,8 @@
#include <lemon/map_defines.h>
#include <lemon/graph_wrapper.h>
#include <iostream>
+using std::cout;
+using std::endl;
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
@@ -125,24 +127,6 @@
NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw,
const _Value& value) :
ParentMap1(gw, value), ParentMap2(gw, value) { }
-// NodeMap(const NodeMap& copy)
-// : ParentMap1(copy),
-// ParentMap2(copy) { }
-// template <typename TT>
-// NodeMap(const NodeMap<TT>& copy)
-// : ParentMap1(copy),
-// ParentMap2(copy) { }
-// NodeMap& operator=(const NodeMap& copy) {
-// ParentMap1::operator=(copy);
-// ParentMap2::operator=(copy);
-// return *this;
-// }
-// template <typename TT>
-// NodeMap& operator=(const NodeMap<TT>& copy) {
-// ParentMap1::operator=(copy);
-// ParentMap2::operator=(copy);
-// return *this;
-// }
_Value operator[](const Node& n) const {
if (!n.backward)
return ParentMap1::operator[](n);
@@ -161,6 +145,7 @@
};
+ //not yet working
template <typename _Graph1, typename _Graph2>
class MergeNodeGraphWrapperBase<
_Graph1, _Graph2, typename boost::enable_if<
@@ -183,6 +168,7 @@
void next() const;
};
+ //not yet working
template <typename _Graph1, typename _Graph2>
class MergeNodeGraphWrapperBase<
_Graph1, _Graph2, typename boost::enable_if<
@@ -205,6 +191,7 @@
void next() const;
};
+ //not yet working
template <typename _Graph1, typename _Graph2>
class MergeNodeGraphWrapperBase<
_Graph1, _Graph2, typename boost::enable_if<
@@ -245,6 +232,128 @@
}
};
+
+ template <typename _Graph, typename _EdgeSetGraph>
+ class NewEdgeSetGraphWrapperBase : public GraphWrapperBase<_Graph> {
+ public:
+ typedef GraphWrapperBase<_Graph> Parent;
+ typedef _Graph Graph;
+ typedef _EdgeSetGraph EdgeSetGraph;
+ typedef typename _Graph::Node Node;
+ typedef typename _EdgeSetGraph::Node ENode;
+ protected:
+ EdgeSetGraph* edge_set_graph;
+ typename Graph::NodeMap<ENode>* e_node;
+ typename EdgeSetGraph::NodeMap<Node>* n_node;
+ void setEdgeSetGraph(EdgeSetGraph& _edge_set_graph) {
+ edge_set_graph=&_edge_set_graph;
+ }
+ /// For each node of \c Graph, this gives a node of \c EdgeSetGraph .
+ void setNodeMap(typename EdgeSetGraph::NodeMap<Node>& _n_node) {
+ n_node=&_n_node;
+ }
+ /// For each node of \c EdgeSetGraph, this gives a node of \c Graph .
+ void setENodeMap(typename Graph::NodeMap<ENode>& _e_node) {
+ e_node=&_e_node;
+ }
+ public:
+ class Edge : public EdgeSetGraph::Edge {
+ typedef typename EdgeSetGraph::Edge Parent;
+ public:
+ Edge() { }
+ Edge(const Parent& e) : Parent(e) { }
+ Edge(Invalid i) : Parent(i) { }
+ };
+
+ using Parent::first;
+ void first(Edge &e) const {
+ edge_set_graph->first(e);
+ }
+ void firstOut(Edge& e, const Node& n) const {
+// cout << e_node << endl;
+// cout << n_node << endl;
+ edge_set_graph->firstOut(e, (*e_node)[n]);
+ }
+ void firstIn(Edge& e, const Node& n) const {
+ edge_set_graph->firstIn(e, (*e_node)[n]);
+ }
+
+ using Parent::next;
+ void next(Edge &e) const {
+ edge_set_graph->next(e);
+ }
+ void nextOut(Edge& e) const {
+ edge_set_graph->nextOut(e);
+ }
+ void nextIn(Edge& e) const {
+ edge_set_graph->nextIn(e);
+ }
+
+ Node source(const Edge& e) const {
+ return (*n_node)[edge_set_graph->source(e)];
+ }
+ Node target(const Edge& e) const {
+ return (*n_node)[edge_set_graph->target(e)];
+ }
+
+ int edgeNum() const { return edge_set_graph->edgeNum(); }
+
+ Edge addEdge(const Node& u, const Node& v) {
+ return edge_set_graph->addEdge((*e_node)[u], (*e_node)[v]);
+ }
+
+ using Parent::erase;
+ void erase(const Edge& i) const { edge_set_graph->erase(i); }
+
+ void clear() const { Parent::clear(); edge_set_graph->clear(); }
+
+ bool forward(const Edge& e) const { return edge_set_graph->forward(e); }
+ bool backward(const Edge& e) const { return edge_set_graph->backward(e); }
+
+ using Parent::id;
+ int id(const Edge& e) const { return edge_set_graph->id(e); }
+
+ Edge opposite(const Edge& e) const { return edge_set_graph->opposite(e); }
+
+ template <typename _Value>
+ class EdgeMap : public EdgeSetGraph::EdgeMap<_Value> {
+ public:
+ typedef typename EdgeSetGraph::EdgeMap<_Value> Parent;
+ typedef _Value Value;
+ typedef Edge Key;
+ EdgeMap(const NewEdgeSetGraphWrapperBase& gw) :
+ Parent(*(gw.edge_set_graph)) { }
+ EdgeMap(const NewEdgeSetGraphWrapperBase& gw, const _Value& _value) :
+ Parent(*(gw.edge_set_graph), _value) { }
+ };
+
+ };
+
+ template <typename _Graph, typename _EdgeSetGraph>
+ class NewEdgeSetGraphWrapper :
+ public IterableGraphExtender<
+ NewEdgeSetGraphWrapperBase<_Graph, _EdgeSetGraph> > {
+ public:
+ typedef _Graph Graph;
+ typedef _EdgeSetGraph EdgeSetGraph;
+ typedef IterableGraphExtender<
+ NewEdgeSetGraphWrapper<_Graph, _EdgeSetGraph> > Parent;
+ protected:
+ NewEdgeSetGraphWrapper() { }
+ public:
+ NewEdgeSetGraphWrapper(_Graph& _graph,
+ _EdgeSetGraph& _edge_set_graph,
+ typename _Graph::
+ NodeMap<typename _EdgeSetGraph::Node>& _e_node,
+ typename _EdgeSetGraph::
+ NodeMap<typename _Graph::Node>& _n_node) {
+ setGraph(_graph);
+ setEdgeSetGraph(_edge_set_graph);
+ setNodeMap(_n_node);
+ setENodeMap(_e_node);
+ }
+ };
+
} //namespace lemon
#endif //LEMON_MERGE_NODE_GRAPH_WRAPPER_H
Modified: hugo/trunk/src/work/marci/merge_node_graph_wrapper_test.cc
==============================================================================
--- hugo/trunk/src/work/marci/merge_node_graph_wrapper_test.cc (original)
+++ hugo/trunk/src/work/marci/merge_node_graph_wrapper_test.cc Thu Nov 18 23:31:21 2004
@@ -4,10 +4,14 @@
#include <lemon/smart_graph.h>
#include <merge_node_graph_wrapper.h>
+#include<lemon/concept_check.h>
+#include<lemon/concept/graph.h>
+
using std::cout;
using std::endl;
using namespace lemon;
+using namespace lemon::concept;
class Graph3 : ListGraph {
public:
@@ -18,6 +22,11 @@
int main() {
typedef SmartGraph Graph1;
typedef ListGraph Graph2;
+
+// {
+// checkConcept<StaticGraph, NewEdgeSetGraphWrapper<Graph1, Graph2> >();
+// }
+ {
Graph1 g;
Graph2 h;
typedef MergeNodeGraphWrapper<Graph1, Graph2> GW;
@@ -77,4 +86,56 @@
GW gw(g, h);
gw.print();
}
+ }
+ {
+ Graph1 g;
+ Graph2 h;
+ typedef Graph1::Node Node1;
+ typedef Graph2::Node Node2;
+ typedef NewEdgeSetGraphWrapper<Graph1, Graph2> GW;
+ Graph1::NodeMap<Graph2::Node> e_node(g);
+ Graph2::NodeMap<Graph1::Node> n_node(h);
+ GW gw(g, h, e_node, n_node);
+ for (int i=0; i<4; ++i) {
+ Node1 n=g.addNode();
+ e_node.set(n, INVALID);
+ }
+ for (int i=0; i<4; ++i) {
+ Graph1::Node n1=g.addNode();
+ Graph2::Node n2=h.addNode();
+ e_node.set(n1, n2);
+ n_node.set(n2, n1);
+ }
+ for (Graph2::NodeIt n(h); n!=INVALID; ++n)
+ for (Graph2::NodeIt m(h); m!=INVALID; ++m)
+ if ((h.id(n)+h.id(m))%3==0) h.addEdge(n, m);
+// Graph1::NodeIt n(g);
+// Node1 n1=n;
+// Node1 n2=++n;
+// Node1 n3=++n;
+// Node1 n4=n;
+// gw.addEdge(n1, n2);
+// gw.addEdge(n1, n2);
+// for (EdgeIt(e))
+// Graph1::Node n1=g.addNode();
+// Graph1::Node n2=g.addNode();
+// Graph1::Node n3=g.addNode();
+// Graph2::Node n4=h.addNode();
+// Graph2::Node n5=h.addNode();
+ for (GW::EdgeIt e(gw); e!=INVALID; ++e)
+ cout << gw.id(e) << endl;
+ for (GW::NodeIt n(gw); n!=INVALID; ++n) {
+ if (e_node[n]==INVALID) {
+ cout<<gw.id(n)<<" INVALID"<<endl;
+ } else {
+ cout <<gw.id(n)<<" "<<h.id(e_node[n])<<" out_edges: ";
+ // cout << &e_node << endl;
+ //cout << &n_node << endl;
+ for (GW::OutEdgeIt e(gw, n); e!=INVALID; ++e) {
+ cout<<gw.id(e)<<" ";
+ }
+ cout<< endl;
+ }
+ }
+ }
}
More information about the Lemon-commits
mailing list