EdgeArray.h

Go to the documentation of this file.

/*
 * $Revision: 2027 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2010-09-01 11:55:17 +0200 (Wed, 01 Sep 2010) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#ifndef OGDF_EDGE_ARRAY_H
#define OGDF_EDGE_ARRAY_H


#include <ogdf/basic/Graph_d.h>


namespace ogdf {



class EdgeArrayBase {
    ListIterator<EdgeArrayBase*> m_it;

public:
    const Graph *m_pGraph; 

    EdgeArrayBase() : m_pGraph(0) { }
    EdgeArrayBase(const Graph *pG) : m_pGraph(pG) {
        if(pG) m_it = pG->registerArray(this);
    }

    // destructor, unregisters the array
    virtual ~EdgeArrayBase() {
        if (m_pGraph) m_pGraph->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 Graph *pG) {
        if (m_pGraph) m_pGraph->unregisterArray(m_it);
        if ((m_pGraph = pG) != 0) m_it = pG->registerArray(this);
    }
}; // class EdgeArrayBase



template<class T> class EdgeArray : private Array<T>, protected EdgeArrayBase {
    T m_x; 

public:
    EdgeArray() : Array<T>(), EdgeArrayBase() { }
    EdgeArray(const Graph &G) : Array<T>(G.edgeArrayTableSize()), EdgeArrayBase(&G) { }

    EdgeArray(const Graph &G, const T &x) :
        Array<T>(0,G.edgeArrayTableSize()-1,x), EdgeArrayBase(&G), m_x(x) { }

    EdgeArray(const EdgeArray<T> &A) : Array<T>(A), EdgeArrayBase(A.m_pGraph), m_x(A.m_x) { }

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

    const Graph *graphOf() const {
        return m_pGraph;
    }

    const T &operator[](edge e) const {
        OGDF_ASSERT(e != 0 && e->graphOf() == m_pGraph)
        return Array<T>::operator [](e->index());
    }

    T &operator[](edge e) {
        OGDF_ASSERT(e != 0 && e->graphOf() == m_pGraph)
        return Array<T>::operator [](e->index());
    }

    const T &operator[](adjEntry adj) const {
        OGDF_ASSERT(adj != 0)
        return Array<T>::operator [](adj->index() >> 1);
    }

    T &operator[](adjEntry adj) {
        OGDF_ASSERT(adj != 0)
        return Array<T>::operator [](adj->index() >> 1);
    }


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


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

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

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

    void init(const Graph &G) {
        Array<T>::init(G.edgeArrayTableSize()); reregister(&G);
    }


    void init(const Graph &G, const T &x) {
        Array<T>::init(0,G.edgeArrayTableSize()-1, m_x = x); reregister(&G);
    }

    void fill(const T &x) {
        int high = m_pGraph->maxEdgeIndex();
        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_pGraph = 0;
    }

    OGDF_NEW_DELETE

}; // class EdgeArray<T>



class OGDF_EXPORT BucketEdgeArray : public BucketFunc<edge>
{
    const EdgeArray<int> *m_pEdgeArray; 

public:

    BucketEdgeArray(const EdgeArray<int> &edgeArray) :
      m_pEdgeArray(&edgeArray) { }

    int getBucket(const edge &e) { return (*m_pEdgeArray)[e]; }
};


} // end namespace ogdf
#include <ogdf/basic/Graph.h>

#endif