NodePCRotation.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/List.h>
#include <ogdf/basic/basic.h>
#include <ogdf/basic/pctree/PCEnum.h>
#include <ogdf/basic/pctree/PCNode.h>
#include <ogdf/basic/pctree/PCRegistry.h>
#include <ogdf/basic/pctree/PCTree.h>
#include <ogdf/basic/pctree/util/IntrusiveList.h>
 
#include <exception>
#include <functional>
#include <iosfwd>
 
namespace ogdf::pc_tree {
class OGDF_EXPORT NodePCRotation : public PCTree {
protected:
    const Graph* m_G;
    node m_n;
 
    PCTreeNodeArray<edge> m_incidentEdgeForLeaf;
    PCTreeNodeArray<node> m_graphNodeForInnerNode;
    PCTreeNodeArray<List<edge>> m_bundleEdgesForLeaf;
 
    NodePCRotation() : m_G(nullptr), m_n(nullptr) { }
 
public:
    explicit NodePCRotation(const Graph& G, node n, bool mapBundleEdges = true);
 
    static node getTrivialPartnerPole(const Graph& G, node n);
 
    node getTrivialPartnerPole() const;
 
    void generateLeafForIncidentEdgeMapping(EdgeArray<PCNode*>& mapping) const {
        for (auto leaf : getLeaves()) {
            mapping[getIncidentEdgeForLeaf(leaf)] = leaf;
        }
    }
 
    edge getIncidentEdgeForLeaf(PCNode* n) const { return m_incidentEdgeForLeaf[n]; }
 
    void setIncidentEdgeForLeaf(PCNode* n, edge e) { m_incidentEdgeForLeaf[n] = e; }
 
    void generateInnerNodeForGraphNodeMapping(NodeArray<PCNode*>& mapping) const {
        for (auto leaf : getLeaves()) {
            mapping[getGraphNodeForInnerNode(leaf)] = leaf;
        }
    }
 
    node getGraphNodeForInnerNode(PCNode* n) const { return m_graphNodeForInnerNode[n]; }
 
    void generatePartnerEdgesForIncidentEdge(EdgeArray<const List<edge>*>& mapping) const {
        for (auto leaf : getLeaves()) {
            mapping[getIncidentEdgeForLeaf(leaf)] = &getPartnerEdgesForLeaf(leaf);
        }
    }
 
    const List<edge>& getPartnerEdgesForLeaf(PCNode* l) const { return m_bundleEdgesForLeaf[l]; }
 
    bool knowsPartnerEdges() const {
        if (m_bundleEdgesForLeaf.registeredAt() == nullptr) {
            return false;
        } else {
            return &m_bundleEdgesForLeaf.registeredAt()->getForest() == getForest();
        }
    }
 
    const Graph* getGraph() const { return m_G; }
 
    node getNode() const { return m_n; }
 
    bool isEqual(const NodePCRotation& pc) const;
 
    std::function<void(std::ostream& os, PCNode*, int)> uidPrinter() const;
 
    std::function<bool(PCNode*, PCNode*)> uidComparer() const;
};
 
struct OGDF_EXPORT GraphNotPlanarException : public std::exception {
public:
    [[nodiscard]] const char* what() const noexcept override { return "Graph is not planar"; }
};
}