ClusterArray.h

Go to the documentation of this file.

/*
 * $Revision: 2299 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2012-05-07 15:57:08 +0200 (Mon, 07 May 2012) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_CLUSTER_ARRAY_H
#define OGDF_CLUSTER_ARRAY_H


#include <ogdf/basic/Array.h>
#include <ogdf/cluster/ClusterGraph.h>


namespace ogdf {


//---------------------------------------------------------
// ClusterArrayBase
// base class for ClusterArray<T>, defines interface for event handling
// used by Graph
//---------------------------------------------------------

class ClusterArrayBase {
    ListIterator<ClusterArrayBase*> m_it;

public:
    const ClusterGraph *m_pClusterGraph; 

    ClusterArrayBase() : m_pClusterGraph(0) { }
    ClusterArrayBase(const ClusterGraph *pC) : m_pClusterGraph(pC) {
        if(pC) m_it = pC->registerArray(this);
    }

    // destructor, unregisters the array
    virtual ~ClusterArrayBase() {
        if (m_pClusterGraph) m_pClusterGraph->unregisterArray(m_it);
    }

    // event interface used by Graph
    virtual void enlargeTable(int newTableSize) = 0;
    virtual void reinit(int initTableSize) = 0;
    virtual void disconnect() = 0;

    void reregister(const ClusterGraph *pC) {
        if (m_pClusterGraph) m_pClusterGraph->unregisterArray(m_it);
        if ((m_pClusterGraph = pC) != 0) m_it = pC->registerArray(this);
    }
}; // class ClusterArrayBase



template<class T> class ClusterArray : private Array<T>, protected ClusterArrayBase {
    T m_x; 

public:
    ClusterArray() : Array<T>(), ClusterArrayBase() { }
    ClusterArray(const ClusterGraph &C) : 
        Array<T>(C.clusterArrayTableSize()), 
        ClusterArrayBase(&C) { }

    ClusterArray(const ClusterGraph &C, const T &x) :
        Array<T>(0,C.clusterArrayTableSize()-1,x), 
        ClusterArrayBase(&C), m_x(x) { }

    ClusterArray(const ClusterGraph &C, const T &x, int size) :
        Array<T>(0,size-1,x),
        ClusterArrayBase(&C), m_x(x) { }


    ClusterArray(const ClusterArray<T> &A) : 
        Array<T>(A), 
        ClusterArrayBase(A.m_pClusterGraph), m_x(A.m_x) { }

    bool valid() const { return (Array<T>::low() <= Array<T>::high()); }
    
    const ClusterGraph *graphOf() const {
        return m_pClusterGraph;
    }

    const T &operator[](cluster c) const {
        OGDF_ASSERT(c != 0 && c->graphOf() == m_pClusterGraph)
        return Array<T>::operator [](c->index());
    }

    T &operator[](cluster c) {
        OGDF_ASSERT(c != 0 && c->graphOf() == m_pClusterGraph)
        return Array<T>::operator [](c->index());
    }


    const T &operator[](int index) const {
        return Array<T>::operator [](index);
    }


    T &operator[](int index) {
        return Array<T>::operator [](index);
    }

    ClusterArray<T> &operator=(const ClusterArray<T> &a) {
        Array<T>::operator =(a);
        m_x = a.m_x;
        reregister(a.m_pClusterGraph);
        return *this;
    }

    void init() {
        Array<T>::init(); reregister(0);
    }

    void init(const ClusterGraph &C) {
        Array<T>::init( C.clusterArrayTableSize() ); reregister(&C);
    }


    void init(const ClusterGraph &C, const T &x) {
        Array<T>::init(0,C.clusterArrayTableSize()-1, m_x = x); reregister(&C);
    }

    void fill(const T &x) {
        int high = m_pClusterGraph->maxClusterIndex();
        if(high >= 0)
            Array<T>::fill(0,high,x);
    }

private:
    virtual void enlargeTable(int newTableSize) {
        Array<T>::grow(newTableSize-Array<T>::size(),m_x);
    }

    virtual void reinit(int initTableSize) {
        Array<T>::init(0,initTableSize-1,m_x);
    }

    virtual void disconnect() {
        Array<T>::init();
        m_pClusterGraph = 0;
    }

    OGDF_NEW_DELETE

}; // class ClusterArray<T>


} // end namespace ogdf


#endif