HypergraphArray.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/hypergraph/Hypergraph.h>
 
namespace ogdf {
 
class HypergraphArrayBase {
public:
    ListIterator<HypergraphArrayBase*> m_it;
 
    const Hypergraph* m_hypergraph;
 
    HypergraphArrayBase() : m_hypergraph(nullptr) { }
 
    explicit HypergraphArrayBase(const Hypergraph* pH) { m_hypergraph = pH; }
 
    virtual ~HypergraphArrayBase() { }
 
    const Hypergraph* hypergraphOf() const { return m_hypergraph; }
 
    virtual void reinit(int initTableSize) = 0;
 
    virtual void reregister(const Hypergraph* H) = 0;
 
    virtual void enlargeTable(int newTableSize) = 0;
 
    virtual void disconnect() = 0;
};
 
 
template<class T>
class HypernodeArray : private Array<T>, protected HypergraphArrayBase {
    T m_x;
 
public:
    HypernodeArray() : Array<T>(), HypergraphArrayBase() { }
 
    HypernodeArray(const Hypergraph& H, const T& x)
        : Array<T>(0, H.hypernodeArrayTableSize() - 1, x), HypergraphArrayBase(&H), m_x(x) {
        m_it = H.registerHypernodeArray(this);
    }
 
    virtual ~HypernodeArray() {
        if (m_hypergraph) {
            m_hypergraph->unregisterHypernodeArray(m_it);
        }
    }
 
    T& operator[](hypernode v) { return Array<T>::operator[](v->index()); }
 
    const T& operator[](int index) const { return Array<T>::operator[](index); }
 
    T& operator[](int index) { return Array<T>::operator[](index); }
 
    HypernodeArray<T>& operator=(const HypernodeArray<T>& a) {
        Array<T>::operator=(a);
        m_x = a.m_x;
        reregister(a.m_hypergraph);
        return *this;
    }
 
    void init(const Hypergraph& H) {
        Array<T>::init(H.hypernodeArrayTableSize());
        reregister(&H);
    }
 
    void init(const Hypergraph& H, const T& x) {
        Array<T>::init(0, H.hypernodeArrayTableSize() - 1, m_x = 0);
        reregister(&H);
    }
 
    virtual void reregister(const Hypergraph* H) {
        if (m_hypergraph) {
            m_hypergraph->unregisterHypernodeArray(m_it);
        }
 
        if ((m_hypergraph = H) != nullptr) {
            m_it = H->registerHypernodeArray(this);
        }
    }
 
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_hypergraph = nullptr;
    }
 
    OGDF_NEW_DELETE;
};
 
 
template<class T>
class HyperedgeArray : private Array<T>, protected HypergraphArrayBase {
    T m_x;
 
public:
    HyperedgeArray() : Array<T>(), HypergraphArrayBase() { }
 
    HyperedgeArray(const Hypergraph& H, const T& x)
        : Array<T>(0, H.hyperedgeArrayTableSize() - 1, x), HypergraphArrayBase(&H), m_x(x) {
        m_it = H.registerHyperedgeArray(this);
    }
 
    virtual ~HyperedgeArray() {
        if (m_hypergraph) {
            m_hypergraph->unregisterHyperedgeArray(m_it);
        }
    }
 
    bool valid() const { return Array<T>::low() <= Array<T>::high(); }
 
    T& operator[](hyperedge e) { return Array<T>::operator[](e->index()); }
 
    const T& operator[](int index) const { return Array<T>::operator[](index); }
 
    T& operator[](int index) { return Array<T>::operator[](index); }
 
    HyperedgeArray<T>& operator=(const HyperedgeArray<T>& a) {
        Array<T>::operator=(a);
        m_x = a.m_x;
        reregister(a.m_hypergraph);
        return *this;
    }
 
    void init(const Hypergraph& H) {
        Array<T>::init(H.hyperedgeArrayTableSize());
        reregister(&H);
    }
 
    void init(const Hypergraph& H, const T& x) {
        Array<T>::init(0, H.hyperedgeArrayTableSize() - 1, m_x = 0);
        reregister(&H);
    }
 
    virtual void reregister(const Hypergraph* H) {
        if (m_hypergraph) {
            m_hypergraph->unregisterHyperedgeArray(m_it);
        }
 
        if ((m_hypergraph = H) != nullptr) {
            m_it = H->registerHyperedgeArray(this);
        }
    }
 
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_hypergraph = nullptr;
    }
 
    OGDF_NEW_DELETE;
};
 
}