//  dizionario.h

#ifndef hashtable_dizionario_h
#define hashtable_dizionario_h

#include <string>
#include <iostream>
using namespace std;

template
class Dizionario {
public:
    Dizionario();
    virtual void inserisci(elemento, chiave)=0;
    virtual void cancella(chiave)=0;
    virtual elemento cerca(chiave)=0;
};

template <class elemento, class chiave>
Dizionario <elemento, chiave>::Dizionario() {
}

#endif


// hash.h

#ifndef hash_h
#define hash_h

class Hash{
public:
    int dimensione();
    int hashValue (string chiave){
        return (string2int(chiave) % MAX);
    }
    int hashValue (int chiave){
        return (chiave % MAX);
    }
private:
    int string2int(string chiave){
        int valore = 0
        //TODO: convertire stringa in intero (p.e. sommando valori ASCII dei caratteri)
        return valore;
    }
};

#endif


// dati.h

#ifndef dati_h
#define dati_h

class Elemento {
public:
    int chiave;
    string valore;
};

#endif


// dizionarioHash.h
#ifndef dizionarioHash_h
#define dizionarioHash_h

#include <iostream>
#include "dizionario.h"
#include "hash.h"
#include "dati.h"
using namespace std;

typedef bool boolean;

template<class elemento, class chiave>
class DizionarioHash: public Dizionario<elemento, chiave> {
    
public:
    void inserisci(elemento, chiave);
    void cancella(chiave);
    elemento cerca(chiave);
    
    DizionarioHash();
private:
    Elemento vettore[MAX];
};


// implementazione metodi
template<class elemento, class chiave>
void DizionarioHash<elemento, chiave>::inserisci(elemento e, chiave c) {
    chiave a = H(c, MAX);
    if ((vettore[a].chiave == c) && (vettore[a].elemento == "")) {
        vettore[a].elemento = e;
    }else{
        bool trovato = false;
        while (!trovato && ((++a % MAX) < MAX)) {
            if (vettore[a].elemento == "") {
                vettore[a].chiave = c;
                vettore[a].elemento = e;
                trovato = true;
            }
        }
    }
}

template<class elemento, class chiave>
void DizionarioHash<elemento, chiave>::cancella(chiave c) {
    chiave a = H(c, MAX);
    if ((vettore[a].chiave == c))) {
        vettore[a].elemento = "";
    }else{
        bool trovato = false;
        while (!trovato && ((++a % MAX) < MAX)) {
            if ((vettore[a].chiave == c)) {
                vettore[a].elemento = "";
                trovato = true;
            }
        }
    }
}

template<class elemento, class chiave>
elemento DizionarioHash<elemento, chiave>::cerca(chiave c) {
    elemento valore = "";
    chiave a = H(c, MAX);
    if (vettore[a].chiave == c){
        valore = vettore[a].elemento;
    }else{
        bool trovato = false;
        while (!trovato && ((++a % MAX) < MAX)) {
            if ((vettore[a].chiave == c)) {
                valore = vettore[a].elemento;
                trovato = true;
            }
        }
    }
    return valore;
}

template <class elemento, class chiave>
DizionarioHash <elemento, chiave>::DizionarioHash() {
    for (int i = 0; i < MAX; i++)
        vettore[i] = "";
}

#endif