node.cpp

用data miming技术进行false prediction

#include "Node.h"
#include "ItemHeaderTable.h"

Node::Node(string name, Node* parent, int count) {
    this->mName = name;
    this->parentNode = parent;
    this->mCount = count;
    this->linkNode = 0;
}

Node::~Node() {
    map<const size_t, Node* , ltstr>::iterator iter;
    for (iter = childrenMap.begin(); iter != childrenMap.end(); iter++) {
        delete (*iter).second;
    }
}

string Node::getName() const {
    return mName;
}

int Node::getCount() const {
    return mCount;
}

int Node::getChildrenCount() const {
    return childrenMap.size();
}

Node* Node::getParentNode() {
    return parentNode;
}

Node* Node::getLinkNode() {
    return linkNode;
}

void Node::setLinkNode(Node* node) {
    linkNode = node;
}

void Node::addChild(Node* child, ItemHeaderTable* iht) {
    size_t h = string_hash(child->getName());
    childrenMap[h] = child;
    iht->processNewNode(child);
}

void Node::incrementCount(int i) {
    mCount += i;
}

void Node::insertTree(vector<Item*>* itemColl, ItemHeaderTable* iht) {
    if (itemColl->size() > 0) {
        vector<Item*>::iterator iter = itemColl->begin();
        Item* i = *iter;

        size_t h = string_hash(i->getName());
        map<const size_t, Node* , ltstr>::iterator curr = childrenMap.find(h);

        Node* node;

        if (curr != childrenMap.end()) {
            node = (*curr).second;
            node->incrementCount(i->getCount());
        } else {
            node = new Node(i->getName(), this, i->getCount());
            this->addChild(node, iht);
        }

        //cout << "insertTree: " << *node << endl;
        delete i;
        itemColl->erase(iter);
        node->insertTree(itemColl, iht);
    }
}

bool Node::hasSingleBranchOnly() {
    if (this->getChildrenCount() > 1) {
        return false;
    } else if (this->getChildrenCount() == 1) {
        map<const size_t, Node* , ltstr>::iterator curr = childrenMap.begin();
        Node* node = (*curr).second;
        return (node->hasSingleBranchOnly());
    } else {
        return true;
    }
}

Node* Node::getLeafNode() {
    if (this->getChildrenCount() > 1) {
        return 0;
    } else if (this->getChildrenCount() == 0) {
        return this;
    } else {
        map<const size_t, Node* , ltstr>::iterator curr = childrenMap.begin();
        Node* currNode = (*curr).second;
        return (currNode->getLeafNode());
    }
}