lemon-0.x: comparison src/hugo/graph

equal deleted inserted replaced

-:f094479c406c
+:6666fe4c46f4
 Node tail(const Edge& e) const {
 return GraphWrapper<Graph>::head(e); }
 Node head(const Edge& e) const {
 return GraphWrapper<Graph>::tail(e); }
-KEEP_MAPS(Parent, RevGraphWrapper);
+//    KEEP_MAPS(Parent, RevGraphWrapper);
 };
 int i=0;
 for (EdgeIt e(*this); e!=INVALID; ++e) ++i;
 return i;
 }
-KEEP_MAPS(Parent, SubGraphWrapper);
+//    KEEP_MAPS(Parent, SubGraphWrapper);
 };
 template<typename Graph>
 	return this->graph->head(e); }
 Node bNode(const OutEdgeIt& e) const {
 if (e.out_or_in) return this->graph->head(e); else
 	return this->graph->tail(e); }
-KEEP_MAPS(Parent, UndirGraphWrapper);
+//    KEEP_MAPS(Parent, UndirGraphWrapper);
 };
 /// \brief An undirected graph template.
 ///
 ///\warning Graph wrappers are in even more experimental state than the other
-///parts of the lib. Use them at you own risk.
+///parts of the lib. Use them at your own risk.
 ///
 /// An undirected graph template.
 /// This class works as an undirected graph and a directed graph of
 /// class \c Graph is used for the physical storage.
 /// \ingroup graphs
 public:
 UndirGraph() : UndirGraphWrapper<Graph>() {
 Parent::setGraph(gr);
 }
-KEEP_MAPS(Parent, UndirGraph);
+//    KEEP_MAPS(Parent, UndirGraph);
 };
 ///\brief A wrapper for composing a subgraph of a
 template <typename T>
 /// \c SubBidirGraphWrapper<..., ..., ...>::EdgeMap contains two
 /// Graph::EdgeMap one for the forward edges and
 /// one for the backward edges.
 class EdgeMap {
+template <typename TT> friend class EdgeMap;
 typename Graph::template EdgeMap<T> forward_map, backward_map;
 public:
 typedef T ValueType;
 typedef Edge KeyType;
 EdgeMap(const SubBidirGraphWrapper<Graph,
 	      ForwardFilterMap, BackwardFilterMap>& g) :
 	forward_map(*(g.graph)), backward_map(*(g.graph)) { }
 EdgeMap(const SubBidirGraphWrapper<Graph,
 	      ForwardFilterMap, BackwardFilterMap>& g, T a) :
 	forward_map(*(g.graph), a), backward_map(*(g.graph), a) { }
+template <typename TT>
+EdgeMap(const EdgeMap<TT>& copy)
+	: forward_map(copy.forward_map), backward_map(copy.backward_map) {}
+template <typename TT>
+EdgeMap& operator=(const EdgeMap<TT>& copy) {
+	forward_map = copy.forward_map;
+	backward_map = copy.backward_map;
+	return *this;
+}
 void set(Edge e, T a) {
 	if (!e.backward)
 	  forward_map.set(e, a);
 	else
 	  backward_map.set(e, a);
 }
-T operator[](Edge e) const {
+typename Graph::template EdgeMap<T>::ConstReferenceType
+operator[](Edge e) const {
 	if (!e.backward)
 	  return forward_map[e];
 	else
 	  return backward_map[e];
 }
+typename Graph::template EdgeMap<T>::ReferenceType
+operator[](Edge e) {
+	if (!e.backward)
+	  return forward_map[e];
+	else
+	  return backward_map[e];
+}
 void update() {
 	forward_map.update();
 	backward_map.update();
 }
 };
-KEEP_NODE_MAP(Parent, SubBidirGraphWrapper);
+//    KEEP_NODE_MAP(Parent, SubBidirGraphWrapper);
 };
 ///\brief A wrapper for composing bidirected graph from a directed one.
 }
 int edgeNum() const {
 return 2*this->graph->edgeNum();
 }
-KEEP_MAPS(Parent, BidirGraphWrapper);
+//    KEEP_MAPS(Parent, BidirGraphWrapper);
 };
 /// \brief A bidirected graph template.
 ///
 Graph gr;
 public:
 BidirGraph() : BidirGraphWrapper<Graph>() {
 Parent::setGraph(gr);
 }
-KEEP_MAPS(Parent, BidirGraph);
+//    KEEP_MAPS(Parent, BidirGraph);
 };
 template<typename Graph, typename Number,
 	else
 	  return (*(res_graph->flow))[e];
 }
 };
-KEEP_MAPS(Parent, ResGraphWrapper);
+//    KEEP_MAPS(Parent, ResGraphWrapper);
 };
 /// For blocking flows.
 typename Graph::OutEdgeIt f(*Parent::graph, n);
 ++f;
 first_out_edges->set(n, f);
 }
-KEEP_MAPS(Parent, ErasingFirstGraphWrapper);
+//    KEEP_MAPS(Parent, ErasingFirstGraphWrapper);
 };
 ///@}
 } //namespace hugo

changeset 891	74589d20dbc3
parent 888	cc3590763f7f
child 892	004636791dd7