PQInternalNode.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/pqtree/PQInternalKey.h> // IWYU pragma: keep
#include <ogdf/basic/pqtree/PQNode.h>
#include <ogdf/basic/pqtree/PQNodeRoot.h>
 
namespace ogdf {
template<class T, class X, class Y>
class PQLeafKey;
template<class T, class X, class Y>
class PQNodeKey;
 
template<class T, class X, class Y>
class PQInternalNode : public PQNode<T, X, Y> {
public:
    PQInternalNode(int count, PQNodeRoot::PQNodeType typ, PQNodeRoot::PQNodeStatus stat,
            PQInternalKey<T, X, Y>* internalPtr, PQNodeKey<T, X, Y>* infoPtr)
        : PQNode<T, X, Y>(count, infoPtr) {
        m_type = typ;
        m_status = stat;
        m_mark = PQNodeRoot::PQNodeMark::Unmarked;
 
        m_pointerToInternal = internalPtr;
        internalPtr->setNodePointer(this);
    }
 
    PQInternalNode(int count, PQNodeRoot::PQNodeType typ, PQNodeRoot::PQNodeStatus stat,
            PQInternalKey<T, X, Y>* internalPtr)
        : PQNode<T, X, Y>(count) {
        m_type = typ;
        m_status = stat;
        m_mark = PQNodeRoot::PQNodeMark::Unmarked;
        m_pointerToInternal = internalPtr;
        internalPtr->setNodePointer(this);
    }
 
    PQInternalNode(int count, PQNodeRoot::PQNodeType typ, PQNodeRoot::PQNodeStatus stat,
            PQNodeKey<T, X, Y>* infoPtr)
        : PQNode<T, X, Y>(count, infoPtr) {
        m_type = typ;
        m_status = stat;
        m_mark = PQNodeRoot::PQNodeMark::Unmarked;
        m_pointerToInternal = 0;
    }
 
    PQInternalNode(int count, PQNodeRoot::PQNodeType typ, PQNodeRoot::PQNodeStatus stat)
        : PQNode<T, X, Y>(count) {
        m_type = typ;
        m_status = stat;
        m_mark = PQNodeRoot::PQNodeMark::Unmarked;
        m_pointerToInternal = nullptr;
    }
 
    ~PQInternalNode() { }
 
    virtual PQLeafKey<T, X, Y>* getKey() const { return nullptr; }
 
    virtual bool setKey(PQLeafKey<T, X, Y>* pointerToKey) { return pointerToKey == nullptr; }
 
    virtual PQInternalKey<T, X, Y>* getInternal() const { return m_pointerToInternal; }
 
    virtual bool setInternal(PQInternalKey<T, X, Y>* pointerToInternal) {
        m_pointerToInternal = pointerToInternal;
        if (pointerToInternal != nullptr) {
            m_pointerToInternal->setNodePointer(this);
            return true;
        } else {
            return false;
        }
    }
 
 
    virtual PQNodeRoot::PQNodeMark mark() const { return m_mark; }
 
    virtual void mark(PQNodeRoot::PQNodeMark m) { m_mark = m; }
 
 
    virtual PQNodeRoot::PQNodeStatus status() const { return m_status; }
 
    virtual void status(PQNodeRoot::PQNodeStatus s) { m_status = s; }
 
 
    virtual PQNodeRoot::PQNodeType type() const { return m_type; }
 
    virtual void type(PQNodeRoot::PQNodeType t) { m_type = t; }
 
private:
    PQNodeRoot::PQNodeMark m_mark;
 
 
    PQInternalKey<T, X, Y>* m_pointerToInternal;
 
    PQNodeRoot::PQNodeStatus m_status;
 
    PQNodeRoot::PQNodeType m_type;
};
 
}