RhodeCode

    struct SetHeap

      : public MaxCardinalitySearch<Digraph, CapacityMap, 

                                    DefHeapTraits<H, CR> > { 

      typedef MaxCardinalitySearch< Digraph, CapacityMap, 

                                    DefHeapTraits<H, CR> > Create;

    };

    template <class H, class CR>

    struct DefStandardHeapTraits : public Traits {

      typedef CR HeapCrossRef;

      typedef H Heap;

      static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {

	return new HeapCrossRef(digraph);

      }

      static Heap *createHeap(HeapCrossRef &crossref) {

	return new Heap(crossref);

      }

    };

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

    /// cross reference type with automatic allocation

    ///

    /// \ref named-templ-param "Named parameter" for setting heap and cross 

    /// reference type. It can allocate the heap and the cross reference 

    /// object if the cross reference's constructor waits for the digraph as 

    /// parameter and the heap's constructor waits for the cross reference.

    template <class H, class CR = typename Digraph::template NodeMap<int> >

    struct SetStandardHeap

      : public MaxCardinalitySearch<Digraph, CapacityMap, 

                                    DefStandardHeapTraits<H, CR> > { 

      typedef MaxCardinalitySearch<Digraph, CapacityMap, 

                                   DefStandardHeapTraits<H, CR> > 

      Create;

    };

    ///@}

  protected:

    MaxCardinalitySearch() {}

  public:      

    /// \brief Constructor.

    ///

    ///\param digraph the digraph the algorithm will run on.

    ///\param capacity the capacity map used by the algorithm.

    MaxCardinalitySearch(const Digraph& digraph,

      _graph(&digraph),

      _capacity(&capacity), local_capacity(false),

      _cardinality(0), local_cardinality(false),

      _processed(0), local_processed(false),

      _heap_cross_ref(0), local_heap_cross_ref(false),

      _heap(0), local_heap(false)

    { }

    /// \brief Destructor.

    ~MaxCardinalitySearch() {

      if(local_capacity) delete _capacity;

      if(local_cardinality) delete _cardinality;

      if(local_processed) delete _processed;

      if(local_heap_cross_ref) delete _heap_cross_ref;

      if(local_heap) delete _heap;

    }

    /// \brief Sets the capacity map.

    ///

    /// Sets the capacity map.

    /// \return <tt> (*this) </tt>

    MaxCardinalitySearch &capacityMap(const CapacityMap &m) {

      if (local_capacity) {

	delete _capacity;

	local_capacity=false;

      }

      _capacity=&m;

      return *this;

    }

    /// \brief Returns a const reference to the capacity map.

    ///

    /// Returns a const reference to the capacity map used by

    /// the algorithm.

    const CapacityMap &capacityMap() const {

      return *_capacity;

    }

    /// \brief Sets the map storing the cardinalities calculated by the 

    /// algorithm.

    ///

    /// Sets the map storing the cardinalities calculated by the algorithm.

    /// If you don't use this function before calling \ref run(),

    /// it will allocate one. The destuctor deallocates this

    /// automatically allocated map, of course.

    /// \return <tt> (*this) </tt>

    MaxCardinalitySearch &cardinalityMap(CardinalityMap &m) {

      if(local_cardinality) {

	delete _cardinality;

	local_cardinality=false;

      }

      _cardinality = &m;

      return *this;

    }

    /// \brief Sets the map storing the processed nodes.