OverlappingGraphCopies.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/Observer.h>
#include <ogdf/basic/basic.h>
#include <ogdf/cluster/sync_plan/basic/GraphMultiArray.h>
 
namespace ogdf {
 
class OverlappingGraphCopies;
 
// room for improvement: common interface with GraphCopyBase, add auto-linking ::insert method
class OGDF_EXPORT OverlappingGraphCopy : public Graph {
    friend class OverlappingGraphCopies;
 
    OverlappingGraphCopies* m_pOGC; 
    NodeArray<node> m_vOrig; 
    EdgeArray<edge> m_eOrig; 
 
    void unmap();
 
public:
    explicit OverlappingGraphCopy(OverlappingGraphCopies& mPOgc)
        : m_pOGC(&mPOgc), m_vOrig(*this, nullptr), m_eOrig(*this, nullptr) { }
 
    ~OverlappingGraphCopy() override { unmap(); }
 
    OGDF_NO_MOVE(OverlappingGraphCopy)
 
    OGDF_NO_COPY(OverlappingGraphCopy)
 
    
    const OverlappingGraphCopies& master() const { return *m_pOGC; }
 
    const Graph& original() const;
 
    node original(node v) const {
        node ov = m_vOrig[v];
        OGDF_ASSERT(ov == nullptr || ov->graphOf() == &original());
        return ov;
    }
 
    edge original(edge e) const {
        edge oe = m_eOrig[e];
        OGDF_ASSERT(oe == nullptr || oe->graphOf() == &original());
        return oe;
    }
 
    adjEntry original(adjEntry adj) const {
        edge f = original(adj->theEdge());
        return adj->isSource() ? f->adjSource() : f->adjTarget();
    }
 
    node copy(node v) const;
 
    edge copy(edge e) const;
 
    adjEntry copy(adjEntry adj) const {
        edge f = copy(adj->theEdge());
        if (f == nullptr) {
            return nullptr;
        }
        return adj->isSource() ? f->adjSource() : f->adjTarget();
    }
 
    bool isDummy(node v) const { return m_vOrig[v] == nullptr; }
 
    bool isDummy(edge e) const { return m_eOrig[e] == nullptr; }
 
    node newNode(node vOrig);
 
    using Graph::newNode;
 
    edge newEdge(edge eOrig);
 
    using Graph::newEdge;
 
    void delEdge(edge e) override;
 
    void delNode(node v) override;
 
    void clear() override {
        unmap();
        Graph::clear();
    }
 
    void breakLinkForMasterDeconstruction() {
        m_pOGC = nullptr;
        m_vOrig.init();
        m_eOrig.init();
    }
};
 
 
class OGDF_EXPORT OverlappingGraphCopies {
    friend class OverlappingGraphCopy;
    using NA = NodeMultiArray<const OverlappingGraphCopy*, node>;
    using EA = EdgeMultiArray<const OverlappingGraphCopy*, edge>;
 
    const Graph* m_G;
    NA m_node_copies;
    EA m_edge_copies;
 
public:
    explicit OverlappingGraphCopies(const Graph& G)
        : m_G(&G), m_node_copies(G), m_edge_copies(G) { }
 
    OGDF_NO_COPY(OverlappingGraphCopies)
 
    OGDF_NO_MOVE(OverlappingGraphCopies)
 
    const NA::EntryType& copies(node n) const { return m_node_copies.get_all(n); }
 
    const EA::EntryType& copies(edge e) const { return m_edge_copies.get_all(e); }
 
    const Graph* constGraph() const { return m_G; }
};
 
}