lemon-main: comparison lemon/adaptors.h

equal deleted inserted replaced

-:fce95d786b7d
+:573f77431e68
 /* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library.
 *
-* Copyright (C) 2003-2009
+* Copyright (C) 2003-2010
 * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
 * (Egervary Research Group on Combinatorial Optimization, EGRES).
 *
 * Permission to use, modify and distribute this software is granted
 * provided that this copyright notice appears in all copies. For
 : Parent(), _node_filter(0), _arc_filter(0) { }
 void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
 Parent::initialize(digraph);
 _node_filter = &node_filter;
 _arc_filter = &arc_filter;
 }
 public:
 typedef typename Parent::Node Node;
 }
 public:
 template <typename V>
 class NodeMap
 : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
+LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
 typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-	LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
+LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 public:
 typedef V Value;
 NodeMap(const SubDigraphBase<DGR, NF, AF, ch>& adaptor)
 return *this;
 }
 };
 template <typename V>
 class ArcMap
 : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
+LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
 LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 public:
 typedef V Value;
 : Parent(), _node_filter(0), _arc_filter(0) { }
 void initialize(DGR& digraph, NF& node_filter, AF& arc_filter) {
 Parent::initialize(digraph);
 _node_filter = &node_filter;
 _arc_filter = &arc_filter;
 }
 public:
 typedef typename Parent::Node Node;
 }
 return arc;
 }
 template <typename V>
 class NodeMap
 : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
 typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 public:
 typedef V Value;
 return *this;
 }
 };
 template <typename V>
 class ArcMap
 : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
 typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
 LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
 }
 return edge;
 }
 template <typename V>
 class NodeMap
 : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
 typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 public:
 typedef V Value;
 return *this;
 }
 };
 template <typename V>
 class ArcMap
 : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
 typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 public:
 typedef V Value;
 return *this;
 }
 };
 template <typename V>
 class EdgeMap
 : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
 typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 public:
 typedef V Value;
 typedef SubGraphBase Adaptor;
 protected:
 NF* _node_filter;
 EF* _edge_filter;
 SubGraphBase()
-	  : Parent(), _node_filter(0), _edge_filter(0) { }
+: Parent(), _node_filter(0), _edge_filter(0) { }
 void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
 Parent::initialize(graph);
 _node_filter = &node_filter;
 _edge_filter = &edge_filter;
 }
 return edge;
 }
 template <typename V>
 class NodeMap
 : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
 typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 public:
 typedef V Value;
 return *this;
 }
 };
 template <typename V>
 class ArcMap
 : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
 typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 public:
 typedef V Value;
 return *this;
 }
 };
 template <typename V>
 class EdgeMap
 : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
 LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
 typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-	LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
+LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 public:
 typedef V Value;
 EdgeMap(const SubGraphBase<GR, NF, EF, false>& adaptor)
 public DigraphAdaptorExtender<
 SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
 true> > {
 #endif
 typedef DigraphAdaptorExtender<
 SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
 true> > Parent;
 public:
 typedef GR Digraph;
 /// \brief Constructor
 ///
 /// Creates a subgraph for the given digraph or graph with the
 /// given node filter map.
 FilterNodes(GR& graph, NF& node_filter)
 : Parent(), const_true_map()
 {
 Parent::initialize(graph, node_filter, const_true_map);
 }
 template<typename GR, typename NF>
 class FilterNodes<GR, NF,
 typename enable_if<UndirectedTagIndicator<GR> >::type> :
 public GraphAdaptorExtender<
 SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
 true> > {
 typedef GraphAdaptorExtender<
 SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
 true> > Parent;
 public:
 typedef GR Graph;
 public DigraphAdaptorExtender<
 SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
 AF, false> > {
 #endif
 typedef DigraphAdaptorExtender<
 SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
 AF, false> > Parent;
 public:
 /// The type of the adapted digraph.
 #else
 template<typename GR,
 typename EF = typename GR::template EdgeMap<bool> >
 class FilterEdges :
 public GraphAdaptorExtender<
 SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
 EF, false> > {
 #endif
 typedef GraphAdaptorExtender<
 SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
 EF, false> > Parent;
 public:
 /// The type of the adapted graph.
 /// \brief Constructor
 ///
 /// Creates a subgraph for the given graph with the given edge
 /// filter map.
 FilterEdges(GR& graph, EF& edge_filter)
 : Parent(), const_true_map() {
 Parent::initialize(graph, const_true_map, edge_filter);
 }
 /// \brief Sets the status of the given edge
 friend class UndirectorBase;
 protected:
 Edge _edge;
 bool _forward;
 Arc(const Edge& edge, bool forward)
 : _edge(edge), _forward(forward) {}
 public:
 Arc() {}
 ArcMapBase(const UndirectorBase<DGR>& adaptor) :
 _forward(*adaptor._digraph), _backward(*adaptor._digraph) {}
 ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
 : _forward(*adaptor._digraph, value),
 _backward(*adaptor._digraph, value) {}
 void set(const Arc& a, const V& value) {
 if (direction(a)) {
 _forward.set(a, value);
 typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;
 NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
 typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
 EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
 typedef EdgeNotifier ArcNotifier;
 ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
 protected:
 #else
 template<typename DGR,
 typename CM = typename DGR::template ArcMap<int>,
 typename FM = CM,
 typename TL = Tolerance<typename CM::Value> >
 class ResidualDigraph
 : public SubDigraph<
 Undirector<const DGR>,
 ConstMap<typename DGR::Node, Const<bool, true> >,
 typename Undirector<const DGR>::template CombinedArcMap<
 _adaptor_bits::ResForwardFilter<const DGR, CM, FM, TL>,
 ///
 /// Constructor of the residual digraph adaptor. The parameters are the
 /// digraph, the capacity map, the flow map, and a tolerance object.
 ResidualDigraph(const DGR& digraph, const CM& capacity,
 FM& flow, const TL& tolerance = Tolerance())
 : Parent(), _capacity(&capacity), _flow(&flow),
 _graph(digraph), _node_filter(),
 _forward_filter(capacity, flow, tolerance),
 _backward_filter(capacity, flow, tolerance),
 _arc_filter(_forward_filter, _backward_filter)
 {
 typedef Arc Key;
 /// The value type of the map
 typedef typename CapacityMap::Value Value;
 /// Constructor
 ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
 : _adaptor(&adaptor) {}
 /// Returns the value associated with the given residual arc
 Value operator[](const Arc& a) const {
 return _adaptor->residualCapacity(a);
 /// \brief Node map combined from two original node maps
 ///
 /// This map adaptor class adapts two node maps of the original digraph
 /// to get a node map of the split digraph.
 /// Its value type is inherited from the first node map type (\c IN).
 /// \tparam IN The type of the node map for the in-nodes.
 /// \tparam OUT The type of the node map for the out-nodes.
 template <typename IN, typename OUT>
 class CombinedNodeMap {
 public:

changeset 900	659ba4805a48
parent 787	c2230649a493
child 998	7fdaa05a69a1