RhodeCode

           class _DeltaMap=typename _Graph::template NodeMap<

             typename _UCapMap::Value>,

           class _Traits=CirculationDefaultTraits<_Graph, _LCapMap,

                                                  _UCapMap, _DeltaMap> >

  class Circulation {

    typedef _Traits Traits;

    typedef typename Traits::Digraph Digraph;

    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);

    typedef typename Traits::Value Value;

    typedef typename Traits::LCapMap LCapMap;

    typedef typename Traits::UCapMap UCapMap;

    typedef typename Traits::DeltaMap DeltaMap;

    typedef typename Traits::FlowMap FlowMap;

    typedef typename Traits::Elevator Elevator;

    typedef typename Traits::Tolerance Tolerance;

    typedef typename Digraph::template NodeMap<Value> ExcessMap;

    const Digraph &_g;

    int _node_num;

    const LCapMap *_lo;

    const UCapMap *_up;

    const DeltaMap *_delta;

    FlowMap *_flow;

    bool _local_flow;

    Elevator* _level;

    bool _local_level;

    ExcessMap* _excess;

    Tolerance _tol;

    int _el;

  public:

    typedef Circulation Create;

    ///\name Named template parameters

    ///@{

    template <typename _FlowMap>

      typedef _FlowMap FlowMap;

      static FlowMap *createFlowMap(const Digraph&) {

        LEMON_ASSERT(false, "FlowMap is not initialized");

        return 0; // ignore warnings

      }

    };

    /// \brief \ref named-templ-param "Named parameter" for setting

    /// FlowMap type

    ///

    /// \ref named-templ-param "Named parameter" for setting FlowMap

    /// type

    template <typename _FlowMap>

      : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,

      typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,

    };

    template <typename _Elevator>

      typedef _Elevator Elevator;

      static Elevator *createElevator(const Digraph&, int) {

        LEMON_ASSERT(false, "Elevator is not initialized");

        return 0; // ignore warnings

      }

    };

    /// \brief \ref named-templ-param "Named parameter" for setting

    /// Elevator type

    ///

    /// \ref named-templ-param "Named parameter" for setting Elevator

    /// type

    template <typename _Elevator>

      : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,

      typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,

    };

    template <typename _Elevator>

      typedef _Elevator Elevator;

      static Elevator *createElevator(const Digraph& digraph, int max_level) {

        return new Elevator(digraph, max_level);

      }

    };

    /// \brief \ref named-templ-param "Named parameter" for setting

    /// Elevator type

    ///

    /// \ref named-templ-param "Named parameter" for setting Elevator

    /// type. The Elevator should be standard constructor interface, ie.

    /// the digraph and the maximum level should be passed to it.

    template <typename _Elevator>

      : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,

      typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,

    };

    /// @}

  protected:

    Circulation() {}

  public:

    /// The constructor of the class.

    /// The constructor of the class.

    /// \param g The digraph the algorithm runs on.

    /// \param lo The lower bound capacity of the arcs.

    /// \param up The upper bound capacity of the arcs.

    /// \param delta The lower bound on node excess.

    Circulation(const Digraph &g,const LCapMap &lo,

                const UCapMap &up,const DeltaMap &delta)

      : _g(g), _node_num(),

        _lo(&lo),_up(&up),_delta(&delta),_flow(0),_local_flow(false),

        _level(0), _local_level(false), _excess(0), _el() {}

    /// Destrcutor.

    ~Circulation() {

      destroyStructures();

    }

  private:

    void createStructures() {

      _node_num = _el = countNodes(_g);

      if (!_flow) {

        _flow = Traits::createFlowMap(_g);

        _local_flow = true;

      }

      if (!_level) {

        _level = Traits::createElevator(_g, _node_num);

        _local_level = true;

      }

      if (!_excess) {

        _excess = new ExcessMap(_g);

      }

    }

    void destroyStructures() {

      if (_local_flow) {