RhodeCode

  /// \ingroup graph_adaptors

  ///

  /// \brief Adaptor class for composing the residual digraph for directed

  /// flow and circulation problems.

  ///

  /// This adaptor implements a digraph structure with node set \f$ V \f$

  /// and arc set \f$ A_{forward}\cup A_{backward} \f$,

  /// where \f$ A_{forward}=\{uv : uv\in A, flow(uv)<cap(uv)\} \f$ and

  /// \f$ A_{backward}=\{vu : uv\in A, flow(uv)>0\} \f$, i.e. the so

  /// called residual digraph.

  /// When the union \f$ A_{forward}\cup A_{backward} \f$ is taken,

  ///

  /// \note The \c Node type of this adaptor and the adapted digraph are

  /// convertible to each other, moreover the \c Arc type of the adaptor

  /// is convertible to the \c Arc type of the adapted digraph.

#ifdef DOXYGEN

  template<typename GR, typename CM, typename FM, typename TL>

#else

  template<typename GR,

           typename CM = typename GR::template ArcMap<int>,

           typename FM = CM,

           typename TL = Tolerance<typename CM::Value> >

    public FilterArcs<

      Undirector<const GR>,

      typename Undirector<const GR>::template CombinedArcMap<

        _adaptor_bits::ResForwardFilter<const GR, CM, FM, TL>,

        _adaptor_bits::ResBackwardFilter<const GR, CM, FM, TL> > >

#endif

    /// The type of the flow map.

    typedef FM FlowMap;

    /// The tolerance type.

    typedef TL Tolerance;

    typedef typename CapacityMap::Value Value;

  protected:

    typedef Undirector<const Digraph> Undirected;

    typedef _adaptor_bits::ResForwardFilter<const Digraph, CapacityMap,

  public:

    /// \brief Constructor

    ///

    /// Constructor of the residual digraph adaptor. The parameters are the

    /// digraph, the capacity map, the flow map, and a tolerance object.

      : Parent(), _capacity(&capacity), _flow(&flow), _graph(digraph),

        _forward_filter(capacity, flow, tolerance),

        _backward_filter(capacity, flow, tolerance),

        _arc_filter(_forward_filter, _backward_filter)

    {

      Parent::setDigraph(_graph);

  /// \brief Returns a (read-only) Residual adaptor

  ///

  /// This function just returns a (read-only) \ref Residual adaptor.

  /// \ingroup graph_adaptors

  /// \relates Residual

  template<typename GR, typename CM, typename FM>

  }

  template <typename _Digraph>

  class SplitNodesBase {

  public:

  Digraph::Arc ad = e3;

  ad = e3;

  Adaptor::Edge ea = a1;

  ea = a2;

}

  // Check concepts

  // Create a digraph and an adaptor

  typedef ListDigraph Digraph;

  typedef Digraph::ArcMap<int> IntArcMap;

  Digraph digraph;

  IntArcMap capacity(digraph), flow(digraph);

  Adaptor adaptor(digraph, capacity, flow);

  Digraph::Node n1 = digraph.addNode();

  // Check the digraph adaptors (using ListDigraph)

  checkReverseDigraph();

  checkSubDigraph();

  checkFilterNodes1();

  checkFilterArcs();

  checkUndirector();

  checkSplitNodes();

  // Check the graph adaptors (using ListGraph)

  checkSubGraph();

  checkFilterNodes2();

  checkFilterEdges();