ClusterArray.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Array.h>
#include <ogdf/cluster/ClusterGraph.h>
 
namespace ogdf {
 
 
class ClusterArrayBase {
    ListIterator<ClusterArrayBase*> m_it;
 
public:
    const ClusterGraph* m_pClusterGraph; 
 
    ClusterArrayBase() : m_pClusterGraph(nullptr) { }
 
    explicit ClusterArrayBase(const ClusterGraph* pC) : m_pClusterGraph(pC) {
        if (pC) {
            m_it = pC->registerArray(this);
        }
    }
 
    ClusterArrayBase(ClusterArrayBase& base)
        : m_it(base.m_it), m_pClusterGraph(base.m_pClusterGraph) {
        if (m_pClusterGraph) {
            m_pClusterGraph->moveRegisterArray(m_it, this);
        }
        base.m_pClusterGraph = nullptr;
        base.m_it = ListIterator<ClusterArrayBase*>();
    }
 
    // 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) != nullptr) {
            m_it = pC->registerArray(this);
        }
    }
 
    void moveRegister(ClusterArrayBase& base) {
        if (m_pClusterGraph) {
            m_pClusterGraph->unregisterArray(m_it);
        }
        m_pClusterGraph = base.m_pClusterGraph;
        m_it = base.m_it;
        base.m_pClusterGraph = nullptr;
        base.m_it = ListIterator<ClusterArrayBase*>();
        if (m_pClusterGraph != nullptr) {
            m_pClusterGraph->moveRegisterArray(m_it, this);
        }
    }
};
 
 
template<class T>
class ClusterArray : private Array<T>, protected ClusterArrayBase {
    T m_x; 
 
public:
    using key_type = cluster;
    using value_type = T;
 
    using iterator = internal::GraphArrayIterator<ClusterArray<T>>;
    using const_iterator = internal::GraphArrayConstIterator<ClusterArray<T>>;
 
    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) { }
 
 
    ClusterArray(ClusterArray<T>&& A) : Array<T>(std::move(A)), ClusterArrayBase(A), 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 != nullptr);
        OGDF_ASSERT(c->graphOf() == m_pClusterGraph);
        return Array<T>::operator[](c->index());
    }
 
    T& operator[](cluster c) {
        OGDF_ASSERT(c != nullptr);
        OGDF_ASSERT(c->graphOf() == m_pClusterGraph);
        return Array<T>::operator[](c->index());
    }
 
    const T& operator()(cluster c) const {
        OGDF_ASSERT(c != nullptr);
        OGDF_ASSERT(c->graphOf() == m_pClusterGraph);
        return Array<T>::operator[](c->index());
    }
 
    T& operator()(cluster c) {
        OGDF_ASSERT(c != nullptr);
        OGDF_ASSERT(c->graphOf() == m_pClusterGraph);
        return Array<T>::operator[](c->index());
    }
 
    OGDF_DEPRECATED("Cluster arrays should be indexed by a cluster, not an integer index.")
 
    const T& operator[](int index) const { return Array<T>::operator[](index); }
 
    OGDF_DEPRECATED("Cluster arrays should be indexed by a cluster, not an integer index.")
 
    T& operator[](int index) { return Array<T>::operator[](index); }
 
 
 
 
    iterator begin() { return iterator(m_pClusterGraph->firstCluster(), this); }
 
 
    const_iterator begin() const { return const_iterator(m_pClusterGraph->firstCluster(), this); }
 
 
    const_iterator cbegin() const { return const_iterator(m_pClusterGraph->firstCluster(), this); }
 
 
    iterator end() { return iterator(nullptr, this); }
 
 
    const_iterator end() const { return const_iterator(nullptr, this); }
 
 
    const_iterator cend() const { return const_iterator(nullptr, this); }
 
 
 
    void init() {
        Array<T>::init();
        reregister(nullptr);
    }
 
    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);
        }
    }
 
    ClusterArray<T>& operator=(const ClusterArray<T>& a) {
        Array<T>::operator=(a);
        m_x = a.m_x;
        reregister(a.m_pClusterGraph);
        return *this;
    }
 
 
    ClusterArray<T>& operator=(ClusterArray<T>&& a) {
        Array<T>::operator=(std::move(a));
        m_x = a.m_x;
        moveRegister(a);
        return *this;
    }
 
 
 
    static key_type findSuccKey(key_type key) { return key->succ(); }
 
    static key_type findPredKey(key_type key) { return key->pred(); }
 
 
private:
    virtual void enlargeTable(int newTableSize) { Array<T>::resize(newTableSize, m_x); }
 
    virtual void reinit(int initTableSize) { Array<T>::init(0, initTableSize - 1, m_x); }
 
    virtual void disconnect() {
        Array<T>::init();
        m_pClusterGraph = nullptr;
    }
 
    OGDF_NEW_DELETE
};
 
}