RhodeCode

    template <class T>

    struct SetCardinalityMap 

      : public MaxCardinalitySearch<Digraph, CapacityMap, 

                                    DefCardinalityMapTraits<T> > { 

      typedef MaxCardinalitySearch<Digraph, CapacityMap, 

                                   DefCardinalityMapTraits<T> > Create;

    };

    template <class T>

    struct DefProcessedMapTraits : public Traits {

      typedef T ProcessedMap;

      static ProcessedMap *createProcessedMap(const Digraph &) {

       	LEMON_ASSERT(false,"Uninitialized parameter.");

	return 0;

      }

    };

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

    /// ProcessedMap type

    ///

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

    /// for the algorithm.

    template <class T>

    struct SetProcessedMap 

      : public MaxCardinalitySearch<Digraph, CapacityMap, 

                                    DefProcessedMapTraits<T> > { 

      typedef MaxCardinalitySearch<Digraph, CapacityMap, 

                                   DefProcessedMapTraits<T> > Create;

    };

    template <class H, class CR>

    struct DefHeapTraits : public Traits {

      typedef CR HeapCrossRef;

      typedef H Heap;

      static HeapCrossRef *createHeapCrossRef(const Digraph &) {

     	LEMON_ASSERT(false,"Uninitialized parameter.");

	return 0;

      }

      static Heap *createHeap(HeapCrossRef &) {

       	LEMON_ASSERT(false,"Uninitialized parameter.");

	return 0;

      }

    };

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

    /// and cross reference type

    ///

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

    /// reference type for the algorithm.

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

    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.

    ///

    /// Sets the map storing the processed nodes.

    /// 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 &processedMap(ProcessedMap &m) 

    {

      if(local_processed) {

	delete _processed;

	local_processed=false;

      }

      _processed = &m;

      return *this;

    }

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

    ///

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

    /// the algorithm.

    const ProcessedMap &processedMap() const {

      return *_processed;

    }

    /// \brief Sets the heap and the cross reference used by algorithm.

    ///

    /// Sets the heap and the cross reference used by 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 &heap(Heap& hp, HeapCrossRef &cr) {

      if(local_heap_cross_ref) {

	delete _heap_cross_ref;

	local_heap_cross_ref = false;

      }

      _heap_cross_ref = &cr;

      if(local_heap) {

	delete _heap;

	local_heap = false;

      }

      _heap = &hp;

      return *this;

    }

    /// \brief Returns a const reference to the heap.

    ///

    /// Returns a const reference to the heap used by