23 #include <lemon/graph_wrapper.h> |
23 #include <lemon/graph_wrapper.h> |
24 #include <iostream> |
24 #include <iostream> |
25 |
25 |
26 namespace lemon { |
26 namespace lemon { |
27 |
27 |
28 template <typename Graph1, typename Graph2, typename Enable=void> |
28 template <typename _Graph1, typename _Graph2, typename Enable=void> |
29 class MergeNodeGraphWrapper : |
29 class MergeNodeGraphWrapperBase : |
30 public GraphWrapper<Graph1>, public GraphWrapper<Graph2> { |
30 public GraphWrapperBase<_Graph1>, public GraphWrapperBase<_Graph2> { |
31 typedef GraphWrapper<Graph1> Parent1; |
|
32 typedef GraphWrapper<Graph2> Parent2; |
|
33 typedef typename GraphWrapper<Graph1>::Node Graph1Node; |
|
34 typedef typename GraphWrapper<Graph2>::Node Graph2Node; |
|
35 public: |
31 public: |
36 class Node; |
32 typedef _Graph1 Graph1; |
37 class NodeIt; |
33 typedef _Graph2 Graph2; |
38 friend class Node; |
34 typedef GraphWrapperBase<_Graph1> Parent1; |
39 friend class NodeIt; |
35 typedef GraphWrapperBase<_Graph2> Parent2; |
40 template<typename Value> class NodeMap; |
36 typedef typename Parent1::Node Graph1Node; |
41 |
37 typedef typename Parent2::Node Graph2Node; |
42 MergeNodeGraphWrapper(Graph1& _graph1, Graph2& _graph2) : |
38 protected: |
43 Parent1(_graph1), Parent2(_graph2) { } |
39 MergeNodeGraphWrapperBase() { } |
|
40 public: |
|
41 template <typename _Value> class NodeMap; |
44 |
42 |
45 class Node : public Graph1Node, public Graph2Node { |
43 class Node : public Graph1Node, public Graph2Node { |
46 friend class MergeNodeGraphWrapper<Graph1, Graph2>; |
44 friend class MergeNodeGraphWrapperBase<_Graph1, _Graph2>; |
47 template<typename Value> friend class NodeMap; |
45 template <typename Value> friend class NodeMap; |
48 protected: |
46 protected: |
49 bool backward; //true, iff backward |
47 bool backward; //true, iff backward |
50 public: |
48 public: |
51 Node() { } |
49 Node() { } |
52 /// \todo =false is needed, or causes problems? |
50 /// \todo =false is needed, or causes problems? |
70 static_cast<Graph2Node>(*this)!= |
68 static_cast<Graph2Node>(*this)!= |
71 static_cast<Graph2Node>(v)); |
69 static_cast<Graph2Node>(v)); |
72 } |
70 } |
73 }; |
71 }; |
74 |
72 |
75 class NodeIt : public Node { |
73 //typedef void Edge; |
76 friend class MergeNodeGraphWrapper<Graph1, Graph2>; |
74 class Edge { }; |
77 protected: |
75 |
78 const MergeNodeGraphWrapper<Graph1, Graph2>* gw; |
76 void first(Node& i) const { |
79 public: |
77 Parent1::graph->first(*static_cast<Graph1Node*>(&i)); |
80 NodeIt() { } |
78 i.backward=false; |
81 NodeIt(Invalid i) : Node(i) { } |
79 if (*static_cast<Graph1Node*>(&i)==INVALID) { |
82 NodeIt(const MergeNodeGraphWrapper<Graph1, Graph2>& _gw) : |
80 Parent2::graph->first(*static_cast<Graph2Node*>(&i)); |
83 Node(typename Graph1::NodeIt(*_gw.Parent1::graph), |
81 i.backward=true; |
84 typename Graph2::Node(), |
82 } |
85 false), gw(&_gw) { |
83 } |
86 if (*static_cast<Graph1Node*>(this)==INVALID) { |
84 void next(Node& i) const { |
87 // *static_cast<Node*>(this)= |
85 if (!(i.backward)) { |
88 // Node(Graph1Node(INVALID), |
86 Parent1::graph->next(*static_cast<Graph1Node*>(&i)); |
89 // typename Graph2::NodeIt(*_gw.Parent2::graph), |
87 if (*static_cast<Graph1Node*>(&i)==INVALID) { |
90 // true); |
88 Parent2::graph->first(*static_cast<Graph2Node*>(&i)); |
91 *static_cast<Graph2Node*>(this)= |
89 i.backward=true; |
92 typename Graph2::NodeIt(*_gw.Parent2::graph); |
|
93 backward=true; |
|
94 } |
90 } |
|
91 } else { |
|
92 Parent2::graph->next(*static_cast<Graph2Node*>(&i)); |
95 } |
93 } |
96 NodeIt(const MergeNodeGraphWrapper<Graph1, Graph2>& _gw, |
94 } |
97 const Node& n) : |
|
98 Node(n), gw(&_gw) { } |
|
99 NodeIt& operator++() { |
|
100 if (!this->backward) { |
|
101 *(static_cast<Graph1Node*>(this))= |
|
102 ++(typename Graph1::NodeIt(*gw->Parent1::graph, *this)); |
|
103 if (*static_cast<Graph1Node*>(this)==INVALID) { |
|
104 // *static_cast<Node*>(this)= |
|
105 // Node(typename Graph1::Node(INVALID), |
|
106 // typename Graph2::NodeIt(*gw->Parent2::graph), true); |
|
107 *static_cast<Graph2Node*>(this)= |
|
108 typename Graph2::NodeIt(*gw->Parent2::graph); |
|
109 backward=true; |
|
110 } |
|
111 } else { |
|
112 *(static_cast<Graph2Node*>(this))= |
|
113 ++(typename Graph2::NodeIt(*gw->Parent2::graph, *this)); |
|
114 } |
|
115 return *this; |
|
116 } |
|
117 }; |
|
118 |
95 |
119 int id(const Node& n) const { |
96 int id(const Node& n) const { |
120 if (!n.backward) |
97 if (!n.backward) |
121 return this->Parent1::graph->id(n); |
98 return this->Parent1::graph->id(n); |
122 else |
99 else |
123 return this->Parent2::graph->id(n); |
100 return this->Parent2::graph->id(n); |
124 } |
101 } |
125 |
102 |
126 template <typename Value> |
103 template <typename _Value> |
127 class NodeMap : public Parent1::template NodeMap<Value>, |
104 class NodeMap : public Parent1::template NodeMap<_Value>, |
128 public Parent2::template NodeMap<Value> { |
105 public Parent2::template NodeMap<_Value> { |
129 typedef typename Parent1::template NodeMap<Value> ParentMap1; |
106 typedef typename Parent1::template NodeMap<_Value> ParentMap1; |
130 typedef typename Parent2::template NodeMap<Value> ParentMap2; |
107 typedef typename Parent2::template NodeMap<_Value> ParentMap2; |
131 public: |
108 public: |
132 NodeMap(const MergeNodeGraphWrapper<Graph1, Graph2>& gw) : |
109 typedef _Value Value; |
133 ParentMap1(gw), |
110 typedef Node Key; |
134 ParentMap2(gw) { } |
111 NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw) : |
135 NodeMap(const MergeNodeGraphWrapper<Graph1, Graph2>& gw, |
112 ParentMap1(gw), ParentMap2(gw) { } |
136 const Value& value) |
113 NodeMap(const MergeNodeGraphWrapperBase<_Graph1, _Graph2>& gw, |
137 : ParentMap1(gw, value), |
114 const _Value& value) : |
138 ParentMap2(gw, value) { } |
115 ParentMap1(gw, value), ParentMap2(gw, value) { } |
139 NodeMap(const NodeMap& copy) |
116 // NodeMap(const NodeMap& copy) |
140 : ParentMap1(copy), |
117 // : ParentMap1(copy), |
141 ParentMap2(copy) { } |
118 // ParentMap2(copy) { } |
142 template <typename TT> |
119 // template <typename TT> |
143 NodeMap(const NodeMap<TT>& copy) |
120 // NodeMap(const NodeMap<TT>& copy) |
144 : ParentMap1(copy), |
121 // : ParentMap1(copy), |
145 ParentMap2(copy) { } |
122 // ParentMap2(copy) { } |
146 NodeMap& operator=(const NodeMap& copy) { |
123 // NodeMap& operator=(const NodeMap& copy) { |
147 ParentMap1::operator=(copy); |
124 // ParentMap1::operator=(copy); |
148 ParentMap2::operator=(copy); |
125 // ParentMap2::operator=(copy); |
149 return *this; |
126 // return *this; |
150 } |
127 // } |
151 template <typename TT> |
128 // template <typename TT> |
152 NodeMap& operator=(const NodeMap<TT>& copy) { |
129 // NodeMap& operator=(const NodeMap<TT>& copy) { |
153 ParentMap1::operator=(copy); |
130 // ParentMap1::operator=(copy); |
154 ParentMap2::operator=(copy); |
131 // ParentMap2::operator=(copy); |
155 return *this; |
132 // return *this; |
156 } |
133 // } |
157 Value operator[](const Node& n) const { |
134 _Value operator[](const Node& n) const { |
158 if (!n.backward) |
135 if (!n.backward) |
159 return ParentMap1::operator[](n); |
136 return ParentMap1::operator[](n); |
160 else |
137 else |
161 return ParentMap2::operator[](n); |
138 return ParentMap2::operator[](n); |
162 } |
139 } |
163 void set(const Node& n, const Value& value) { |
140 void set(const Node& n, const _Value& value) { |
164 if (!n.backward) |
141 if (!n.backward) |
165 ParentMap1::set(n, value); |
142 ParentMap1::set(n, value); |
166 else |
143 else |
167 ParentMap2::set(n, value); |
144 ParentMap2::set(n, value); |
168 } |
145 } |
169 using ParentMap1::operator[]; |
146 using ParentMap1::operator[]; |
170 using ParentMap2::operator[]; |
147 using ParentMap2::operator[]; |
171 }; |
148 }; |
172 |
149 |
|
150 }; |
|
151 |
|
152 |
|
153 template <typename _Graph1, typename _Graph2, typename Enable=void> |
|
154 class MergeNodeGraphWrapper : public |
|
155 IterableGraphExtender<MergeNodeGraphWrapperBase<_Graph1, _Graph2, Enable> > { |
|
156 public: |
|
157 typedef _Graph1 Graph1; |
|
158 typedef _Graph2 Graph2; |
|
159 typedef IterableGraphExtender< |
|
160 MergeNodeGraphWrapperBase<_Graph1, _Graph2, Enable> > Parent; |
|
161 protected: |
|
162 MergeNodeGraphWrapper() { } |
|
163 public: |
|
164 MergeNodeGraphWrapper(_Graph1& _graph1, _Graph2& _graph2) { |
|
165 Parent::Parent1::setGraph(_graph1); |
|
166 Parent::Parent2::setGraph(_graph2); |
|
167 } |
173 }; |
168 }; |
174 |
169 |
175 } //namespace lemon |
170 } //namespace lemon |
176 |
171 |
177 #endif //LEMON_MERGE_NODE_GRAPH_WRAPPER_H |
172 #endif //LEMON_MERGE_NODE_GRAPH_WRAPPER_H |