PQLeaf.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/pqtree/PQNode.h>
 
namespace ogdf {
 
template<class T, class X, class Y>
class PQLeaf : public PQNode<T, X, Y> {
public:
    PQLeaf(int count, PQNodeRoot::PQNodeStatus stat, PQLeafKey<T, X, Y>* keyPtr,
            PQNodeKey<T, X, Y>* infoPtr)
        : PQNode<T, X, Y>(count, infoPtr) {
        m_status = stat;
        m_pointerToKey = keyPtr;
        m_mark = PQNodeRoot::PQNodeMark::Unmarked;
        keyPtr->setNodePointer(this);
    }
 
    // Constructor
    PQLeaf(int count, PQNodeRoot::PQNodeStatus stat, PQLeafKey<T, X, Y>* keyPtr)
        : PQNode<T, X, Y>(count) {
        m_status = stat;
        m_pointerToKey = keyPtr;
        m_mark = PQNodeRoot::PQNodeMark::Unmarked;
        keyPtr->setNodePointer(this);
    }
 
    virtual ~PQLeaf() { }
 
    virtual PQLeafKey<T, X, Y>* getKey() const { return m_pointerToKey; }
 
    virtual bool setKey(PQLeafKey<T, X, Y>* pointerToKey) {
        m_pointerToKey = pointerToKey;
        if (pointerToKey != nullptr) {
            m_pointerToKey->setNodePointer(this);
            return true;
        } else {
            return false;
        }
    }
 
    virtual PQInternalKey<T, X, Y>* getInternal() const { return nullptr; }
 
    virtual bool setInternal(PQInternalKey<T, X, Y>* pointerToInternal) {
        if (pointerToInternal != nullptr) {
            return false;
        } else {
            return true;
        }
    }
 
 
    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 PQNodeRoot::PQNodeType::Leaf; }
 
    virtual void type(PQNodeRoot::PQNodeType) { }
 
private:
    PQNodeRoot::PQNodeMark m_mark;
 
    PQLeafKey<T, X, Y>* m_pointerToKey;
 
    PQNodeRoot::PQNodeStatus m_status;
};
 
}