RhodeCode

      while (i != INVALID && (!(*_arc_filter)[i]

                              || !(*_node_filter)[Parent::source(i)]))

        Parent::nextIn(i);

    }

    void nextOut(Arc& i) const {

      Parent::nextOut(i);

      while (i != INVALID && (!(*_arc_filter)[i]

                              || !(*_node_filter)[Parent::target(i)]))

        Parent::nextOut(i);

    }

    typedef False NodeNumTag;

    typedef False ArcNumTag;

    typedef FindArcTagIndicator<Digraph> FindArcTag;

    Arc findArc(const Node& source, const Node& target,

                const Arc& prev = INVALID) const {

      if (!(*_node_filter)[source] || !(*_node_filter)[target]) {

        return INVALID;

      }

      Arc arc = Parent::findArc(source, target, prev);

      while (arc != INVALID && !(*_arc_filter)[arc]) {

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::next(i);

    }

    void nextIn(Arc& i) const {

      Parent::nextIn(i);

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextIn(i);

    }

    void nextOut(Arc& i) const {

      Parent::nextOut(i);

      while (i!=INVALID && !(*_arc_filter)[i]) Parent::nextOut(i);

    }

    typedef False NodeNumTag;

    typedef False ArcNumTag;

    typedef FindArcTagIndicator<Digraph> FindArcTag;

    Arc findArc(const Node& source, const Node& target,

                const Arc& prev = INVALID) const {

      if (!(*_node_filter)[source] || !(*_node_filter)[target]) {

        return INVALID;

      }

      Arc arc = Parent::findArc(source, target, prev);

      while (arc != INVALID && !(*_arc_filter)[arc]) {

    /// \brief Constructor

    ///

    /// Creates a subdigraph for the given digraph with the

    /// given node and arc filter maps.

    SubDigraph(Digraph& digraph, NodeFilterMap& node_filter,

               ArcFilterMap& arc_filter) {

      setDigraph(digraph);

      setNodeFilterMap(node_filter);

      setArcFilterMap(arc_filter);

    }

    ///

    /// It is done by simply setting the assigned value of \c n

    ///

    /// It is done by simply setting the assigned value of \c a

    ///

    ///

    ///

    ///

  };

  /// \brief Returns a read-only SubDigraph adaptor

  ///

  /// This function just returns a read-only \ref SubDigraph adaptor.

  /// \ingroup graph_adaptors

  /// \relates SubDigraph

  template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>

  SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap>

  subDigraph(const Digraph& digraph, NodeFilterMap& nfm, ArcFilterMap& afm) {

    return SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap>

                            || !(*_node_filter_map)[Parent::target(i)]))

        Parent::nextOut(i);

    }

    void nextInc(Edge& i, bool& d) const {

      Parent::nextInc(i, d);

      while (i!=INVALID && (!(*_edge_filter_map)[i]

                            || !(*_node_filter_map)[Parent::u(i)]

                            || !(*_node_filter_map)[Parent::v(i)]))

        Parent::nextInc(i, d);

    }

    typedef False NodeNumTag;

    typedef False ArcNumTag;

    typedef False EdgeNumTag;

    typedef FindArcTagIndicator<Graph> FindArcTag;

    Arc findArc(const Node& u, const Node& v,

                const Arc& prev = INVALID) const {

      if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {

        return INVALID;

      }

      Arc arc = Parent::findArc(u, v, prev);

      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextIn(i);

    }

    void nextOut(Arc& i) const {

      Parent::nextOut(i);

      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextOut(i);

    }

    void nextInc(Edge& i, bool& d) const {

      Parent::nextInc(i, d);

      while (i!=INVALID && !(*_edge_filter_map)[i]) Parent::nextInc(i, d);

    }

    typedef False NodeNumTag;

    typedef False ArcNumTag;

    typedef False EdgeNumTag;

    typedef FindArcTagIndicator<Graph> FindArcTag;

    Arc findArc(const Node& u, const Node& v,

                const Arc& prev = INVALID) const {

      Arc arc = Parent::findArc(u, v, prev);

      while (arc != INVALID && !(*_edge_filter_map)[arc]) {

        arc = Parent::findArc(u, v, arc);

      }

    /// \brief Constructor

    ///

    /// Creates a subgraph for the given graph with the given node

    /// and edge filter maps.

    SubGraph(Graph& graph, NodeFilterMap& node_filter_map,

             EdgeFilterMap& edge_filter_map) {

      setGraph(graph);

      setNodeFilterMap(node_filter_map);

      setEdgeFilterMap(edge_filter_map);

    }

    ///

    /// It is done by simply setting the assigned value of \c n

    ///

    /// It is done by simply setting the assigned value of \c e

    ///

    ///

    ///

    ///

  };

  /// \brief Returns a read-only SubGraph adaptor

  ///

  /// This function just returns a read-only \ref SubGraph adaptor.

  /// \ingroup graph_adaptors

  /// \relates SubGraph

  template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>

  SubGraph<const Graph, NodeFilterMap, ArcFilterMap>

  subGraph(const Graph& graph, NodeFilterMap& nfm, ArcFilterMap& efm) {

    return SubGraph<const Graph, NodeFilterMap, ArcFilterMap>(graph, nfm, efm);

  }

    /// given node filter map.

#ifdef DOXYGEN

    FilterNodes(_Graph& graph, _NodeFilterMap& node_filter) :

#else

    FilterNodes(Digraph& graph, NodeFilterMap& node_filter) :

#endif

      Parent(), const_true_map(true) {

      Parent::setDigraph(graph);

      Parent::setNodeFilterMap(node_filter);

      Parent::setArcFilterMap(const_true_map);

    }

    ///

    /// It is done by simply setting the assigned value of \c n

    ///

    ///

  };

  template<typename _Graph, typename _NodeFilterMap, bool _checked>

  class FilterNodes<_Graph, _NodeFilterMap, _checked,

                    typename enable_if<UndirectedTagIndicator<_Graph> >::type>

    : public SubGraph<_Graph, _NodeFilterMap,

                      ConstMap<typename _Graph::Edge, bool>, _checked> {

  public:

    typedef _Graph Graph;

    typedef _NodeFilterMap NodeFilterMap;

    typedef SubGraph<Graph, NodeFilterMap,

      Parent::setEdgeFilterMap(const_true_map);

    }

  public:

    FilterNodes(Graph& _graph, NodeFilterMap& node_filter_map) :

      Parent(), const_true_map(true) {

      Parent::setGraph(_graph);

      Parent::setNodeFilterMap(node_filter_map);

      Parent::setEdgeFilterMap(const_true_map);

    }

  };

  /// \brief Returns a read-only FilterNodes adaptor

  ///

  /// This function just returns a read-only \ref FilterNodes adaptor.

  /// \ingroup graph_adaptors

  /// \relates FilterNodes

  template<typename Digraph, typename NodeFilterMap>

  FilterNodes<const Digraph, NodeFilterMap>

  filterNodes(const Digraph& digraph, NodeFilterMap& nfm) {

    /// \brief Constructor

    ///

    /// Creates a subdigraph for the given digraph with the given arc

    /// filter map.

    FilterArcs(Digraph& digraph, ArcFilterMap& arc_filter)

      : Parent(), const_true_map(true) {

      Parent::setDigraph(digraph);

      Parent::setNodeFilterMap(const_true_map);

      Parent::setArcFilterMap(arc_filter);

    }

    ///

    /// It is done by simply setting the assigned value of \c a

    ///

    ///

  };

  /// \brief Returns a read-only FilterArcs adaptor

  ///

  /// This function just returns a read-only \ref FilterArcs adaptor.

  /// \ingroup graph_adaptors

  /// \relates FilterArcs

  template<typename Digraph, typename ArcFilterMap>

  FilterArcs<const Digraph, ArcFilterMap>

  filterArcs(const Digraph& digraph, ArcFilterMap& afm) {

    return FilterArcs<const Digraph, ArcFilterMap>(digraph, afm);

    /// \brief Constructor

    ///

    /// Creates a subgraph for the given graph with the given edge

    /// filter map.

    FilterEdges(Graph& graph, EdgeFilterMap& edge_filter_map) :

      Parent(), const_true_map(true) {

      Parent::setGraph(graph);

      Parent::setNodeFilterMap(const_true_map);

      Parent::setEdgeFilterMap(edge_filter_map);

    }

    ///

    /// It is done by simply setting the assigned value of \c e

    ///

    ///

  };

  /// \brief Returns a read-only FilterEdges adaptor

  ///

  /// This function just returns a read-only \ref FilterEdges adaptor.

  /// \ingroup graph_adaptors

  /// \relates FilterEdges

  template<typename Graph, typename EdgeFilterMap>

  FilterEdges<const Graph, EdgeFilterMap>

  filterEdges(const Graph& graph, EdgeFilterMap& efm) {

    return FilterEdges<const Graph, EdgeFilterMap>(graph, efm);

    /// \brief Returns the residual capacity of the given arc.

    ///

    /// Returns the residual capacity of the given arc.

    Value residualCapacity(const Arc& a) const {

      if (Undirected::direction(a)) {

        return (*_capacity)[a] - (*_flow)[a];

      } else {

        return (*_flow)[a];

      }

    }

    ///

    /// or decreases the flow value on the original arc according to the

    /// direction of the residual arc.

    void augment(const Arc& a, const Value& v) const {

      if (Undirected::direction(a)) {

        _flow->set(a, (*_flow)[a] + v);

      } else {

        _flow->set(a, (*_flow)[a] - v);

      }

    }

    /// \brief Returns \c true if the given residual arc is a forward arc.

    ///