#ifndef __ASSOC_H
#define __ASSOC_H

#ifndef __STRINGS_H
#include <strings.h>
#endif

// @doc EXTERNAL
//
// @class THash_object | Classe per la definizione degli elementi di una tabella hash.
//
// @base public | TObject
class THash_object : public TObject
{
  // @cfriend TAssoc_array
  friend class TAssoc_array;

  // @access Private Member

  // @cmember Chiave d'ordinamento
  TString  _key;
  // @cmember Oggetto della tabella da ordinare
  TObject* _obj;

  // @access Public Member
public:
  
  // @cmember Ritorna la chiave di ordinamento
  TString& key()
  { return _key; }
  // @cmember Ritorna l'oggetto
  TObject& obj()
  { return *_obj; }

  // @cmember Costruttore (inizializza la chiave)
  THash_object(const char* k) : _key(k), _obj(NULL)
  {}
  // @cmember Distruttore
  ~THash_object()
  { if (_obj != NULL) delete _obj; }
}; 


// @class TAssoc_array | Tabella hash di oggetti generici
//
// @base public |TObject
class TAssoc_array : public TObject
{

  //@access Private Member

  // @ccost HASH_SIZE | 113 | Dimensione della tabella hash
  enum { HASH_SIZE = 113 };
  // @cmember Numero di oggetti contenuti nella tabella
  word _cnt;
  // @cmember Numero di righe della tabella hash
  word _row;
  // @cmember Numero di colonne della tabella hash
  word _col;
  // @cmember Array contenente i dati veri e propri
  TArray _data[HASH_SIZE];
  
  // @access Protected member
protected:

  // @cmember Cerca l'oggetto con chiave k
  THash_object* _lookup(const char* k, bool& isnew, bool insert = FALSE);

  // @access Public Member
public:

  // @cmember Ritorna il numero di elementi presenti
  int items() const
  { return _cnt; }
  
  // @cmember Cancella tutti gli elementi
  virtual void destroy();

  // @cmember Aggiunge un oggetto. Se era gia' presente guarda il parametro force
  bool add(const char* key, TObject* obj = NULL, bool force = FALSE);

  // @cmember Aggiunge una copia dell'oggetto
  bool add(const char* key, const TObject& obj, bool force = FALSE);

  // @cmember Elimina un oggetto
  bool remove(const char* key);

  // @cmember Trova l'oggetto indicizzato
  TObject& find(const char* key);

  // @cmember Ritorna l'oggetto con chiave key
  TObject* objptr(const char* key);

  // @cmember Controlla l'esistenza di una chiave
  bool is_key(const char* key);

  // @cmember Ritorna l'indice del oggetto con chiave key (piu' intuitivo di <mf TAssoc_array::find>)
  TObject& operator[] (const char* key)
  { return find(key); }
  
  // iterazione come TToken_string
  // si puo' adoperare get() e get_hashobj() intercambiabilmente ma
  // non sono indipendenti (entrambe avanzano gli stessi contatori)

  // @cmember Ritorna solo l'oggetto
  TObject* get();
  // @cmember Ritorna l'oggetto e la relativa chiave
  THash_object* get_hashobj();
  // @cmember Azzera il numero di righe e colonne della tabella hash
  void restart()
  { _row = 0; _col = 0; }
                                                        
  // mette chiavi e opzionalmente valori (come stringa) nel
  // TString_array passato                                                      
  int get_keys(TString_array& kl, bool add_values = FALSE);

  // @cmember Costruttore
  TAssoc_array()  : _cnt(0), _row(0), _col(0)
  {}
  // @cmember Distruttore
  virtual ~TAssoc_array() { destroy(); }  
};

#endif