/*
 * HashTable.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL++2000

#pragma once

#include <sol\Object.h>
#include <sol\HashEntry.h>

namespace SOL {

class HashTable    :public Object {
private:
    int     size;
    HashEntry** table;

    Key     hash(const Key key) { return (key % size); }

private:
    Key hash(const char* key)
    {
        long sum = 0;
        int len  = strlen(key);

        for(int i = 0; i<len; i++) {
            sum = sum + ((int)*key % size);
            key++;
        }
        return (Key)(sum % size);
    }

public:
    HashTable(int size1)
    {
        size = size1;
        table = new HashEntry*[size];

        for (int i =0 ; i<size; i++) {
            table[i] = NULL;
        }
    }

public:
    void    add(Key key, Object* object)
    {
        Key n = hash(key);
        HashEntry* entry = new HashEntry(key, object);
        entry -> add(table[n]);
        table[n] = entry;
    }

public:
    void    add(const char* key, Object* object)
    {
        Key  n = hash(key);
        HashEntry* entry = new HashEntry(key, object);
        entry -> add(table[n]);
        table[n] = entry;
    }

public:
    Object* lookup(Key key)
    {
        Object* object = NULL;
        Key  n = hash(key);
        HashEntry* ptr = table[n];

        while (ptr) {
            if (ptr -> getIntKey() == key) {
                object = ptr -> getObject();
                break;
            }
            ptr = ptr -> getNext();
        }
        return object;
    }

public:
    Object* lookup(const char* key)
    {
        Key n = hash(key);
        HashEntry* ptr = table[n];
        Object* object = NULL;

        while (ptr) {
            if(strcmp(ptr -> getCharKey(), key)==0) {
                object = ptr->getObject();
                break;
            }
            ptr = ptr -> getNext();
        }
        return object;
    }

public:
    int remove(HashEntry* prev, HashEntry* ptr, int n)
    {
        if (ptr == NULL) {
            return False;
        }
        if (prev == ptr) {
            table[n] = ptr -> getNext();
        }
        else {
            prev -> add(ptr -> getNext());
        }
        delete ptr;
        return True;
    }

public:
    int remove(Key key)
    {
        Key n = hash(key);
        HashEntry* ptr  = table[n];
        HashEntry* prev = ptr;

        while(ptr) {
            if(ptr -> getIntKey() == key) {
                remove(prev, ptr, n);
                return True;
            }
            prev = ptr;
            ptr  = ptr -> getNext();
        }
        return False;
    }

public:
    int remove(const char* key)
    {
        Key n = hash(key);
        HashEntry* ptr  = table[n];
        HashEntry* prev = ptr;

        while (ptr) {
            if(strcmp(ptr -> getCharKey(), key)==0 ) {
                remove(prev, ptr, n);
                return True;
            }
            prev = ptr;
            ptr  = ptr -> getNext();
        }
        return False;
    }

public:
    ~HashTable()
    {
        for(int i = 0; i < size; i++) {
            HashEntry* ptr  = table[i];
            HashEntry* prev = ptr;
            while(ptr) {
                prev = ptr;
                ptr  = ptr -> getNext();
                delete prev;
            }
        }

        delete [] table;
    }


};

}