node_table.h

Go to the documentation of this file.

/*
 * node_table.h
 *
 * LICENSE HERE
 *
 *  Created on: 2016-09-12
 *      Author: Rick Valenzano
 */

#ifndef NODE_TABLE_H_
#define NODE_TABLE_H_

#include <cassert>
#include <vector>
#include <unordered_map>
#include <utility>
#include <stdio.h>
#include <iostream>
#include "../../generic_defs/state_hash_function.h"

typedef unsigned NodeID; 

struct NodeKeyHash
{
    std::size_t operator()(StateHash hash_value) const;
};

template<class node_t>
class NodeTable
{
    typedef std::unordered_map<StateHash, NodeID, NodeKeyHash> NodeMap; 

public:
    NodeTable();

    virtual ~NodeTable();

    bool isNodeStored(StateHash hash_value, NodeID &id) const;

    NodeID addNewSearchNode(node_t new_node, StateHash hash_value);

    void clear();

    std::size_t size() const;

    node_t &getNode(NodeID node_id);

    const node_t &getNode(NodeID node_id) const;

    node_t &operator[](NodeID node_id);

    const node_t &operator[](NodeID node_id) const;

protected:
    std::vector<node_t> nodes; 

    NodeMap node_map; 
};

template<class node_t>
inline NodeTable<node_t>::NodeTable()
{
}

template<class node_t>
inline NodeTable<node_t>::~NodeTable()
{
}

template<class node_t>
bool NodeTable<node_t>::isNodeStored(StateHash hash_value, NodeID& id) const
{
    assert(nodes.size() == node_map.size());

    typename NodeMap::const_iterator node_check = node_map.find(hash_value);

    if(node_check == node_map.end())
        return false;

    id = node_check->second;
    assert(id < nodes.size());
    return true;
}

template<class node_t>
NodeID NodeTable<node_t>::addNewSearchNode(node_t new_node, StateHash hash_value)
{
    nodes.push_back(new_node);
    node_map[hash_value] = nodes.size() - 1;

    return nodes.size() - 1;
}

template<class node_t>
void NodeTable<node_t>::clear()
{
    nodes.clear();
    node_map.clear();
}

template<class node_t>
node_t& NodeTable<node_t>::getNode(NodeID node_id)
{
    if(node_id >= nodes.size()) {
        //std::cout << "Bad node id " << node_id << std::endl;
        assert(false);
    }
    return nodes[node_id];
}

template<class node_t>
const node_t& NodeTable<node_t>::getNode(NodeID node_id) const
{
    if(node_id >= nodes.size()) {
        //std::cout << "Bad node id " << node_id << std::endl;
        assert(false);
    }
    return nodes[node_id];
}

template<class node_t>
inline std::size_t NodeTable<node_t>::size() const
{
    return nodes.size();
}

template<class node_t>
node_t& NodeTable<node_t>::operator [](NodeID node_id)
{
    return getNode(node_id);
}

template<class node_t>
const node_t& NodeTable<node_t>::operator [](NodeID node_id) const
{
    return getNode(node_id);
}

#endif /* NODE_TABLE_H_ */