campo-sirio/src/include/assoc.h

#ifndef __ASSOC_H
#define __ASSOC_H

#ifndef __ARRAY_H
#include <array.h>
#endif

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

// @doc INTERNAL

// @class THash_object | Classe per la definizione degli elementi di una tabella hash.
//
// @base public | TObject

class THash_object : public TObject
// @author:(INTERNAL) Villa
{
  // @cfriend TAssoc_array
  friend class TAssoc_array;  
  // @cfriend TIndexed_array
  friend class TIndexed_array;

  // @access:(INTERNAL) Private Member

  // @cmember:(INTERNAL) Chiave d'ordinamento
  TString  _key;
  // @cmember:(INTERNAL) Oggetto da memorizzare
  TObject* _obj;

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

  TObject* remove_obj() { TObject* o = _obj; _obj = nullptr; return o; }

  // @cmember Costruttore (inizializza la chiave ed opzionalmente l'oggetto)
  THash_object(const char* k, TObject* o = nullptr) : _key(k), _obj(o)
  {}
  // @cmember Distruttore
  virtual ~THash_object();
}; 

// @doc EXTERNAL

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

// @author:(INTERNAL) Villa

//@access:(INTERNAL) Private Member
{
  // @cmember:(INTERNAL) Numero di oggetti contenuti nella tabella
  word _cnt;
  // @cmember:(INTERNAL) Numero di righe della tabella hash
  word _row;
  // @cmember:(INTERNAL) Numero di colonne della tabella hash
  word _col;
  // @cmember:(INTERNAL) Numero di righe della tabella hash per i metodi _item
  int _rowitem;
  // @cmember:(INTERNAL) Numero di colonne della tabella hash per i metodi _item
  int _colitem;
  // @cmember:(INTERNAL) Array contenente i dati veri e propri
  TArray _bucket;
  
  // @access Protected member
protected:
  TArray& bucket(int index);
  
  // @cmember Cerca l'oggetto con chiave k
  THash_object* _lookup(const char* k, bool& isnew, bool insert = FALSE);  
  // @cmember Copia tutto l'array associativo e ne duplica gli elementi
  TAssoc_array & copy(const TAssoc_array & a);  

  // @access Public Member
public:
  // @cmember Duplica l'array associativo copiandone gli elementi.
  virtual TObject* dup () const { return new TAssoc_array(*this);}

  // @cmember Ritorna un puntatore al primo oggetto
  virtual TObject* first_item( );
  // @cmember Ritorna un puntatore all'ultimo oggetto
  virtual TObject* last_item( );
  // @cmember Ritorna un puntatore all'oggetto successivo al quello corrente
  virtual TObject* succ_item( );
  // @cmember Ritorna un puntatore all'oggetto che precede quello corrente
  virtual TObject* pred_item( );
  // @cmember Ritorna un puntatore ad un THash_object casuale (anche NULL)
  THash_object* random_hash_object();

  // @cmember Ritorna il numero di elementi presenti come long  
  virtual long objects() const { return _cnt; }

  // @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 Controlla l'esistenza di una chiave
  bool is_key(const char* key) const ;

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

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

  // @cmember Ritorna l'indice del oggetto con chiave key (piu' intuitivo di <mf TAssoc_array::find>)
  TObject& operator[] (const char* key) const
  { 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 Azzera il numero di riga e colonna corrente della tabella hash
  void restart()
  { _row = 0; _col = 0; }
  // @cmember Ritorna solo l'oggetto
  TObject* get();
  // @cmember Ritorna l'oggetto e la relativa chiave
  THash_object* get_hashobj();
  
  bool get_bool(const char* key) const;
  int get_int(const char* key) const;
  const TString& get_str(const char* key) const;
                                                        
  // @cmember Mette chiavi e opzionalmente valori (come stringa) nel <c TString_array> passato  
  int get_keys(TString_array& kl, bool add_values = false);
  // @cmember Operatore di assegnamento tra array associativi
  TAssoc_array& operator= (const TAssoc_array & a)
  { return copy(a); }
  
  // @cmember Costruttore
  TAssoc_array()  : _cnt(0), _row(0), _col(0)
  {}
  // @cmember Costruttore. Copia tutto l'array associativo e ne duplica gli elementi
  TAssoc_array(const TAssoc_array& a) : _cnt(0), _row(0), _col(0)
  { copy(a); }
  // @cmember Distruttore
  virtual ~TAssoc_array() 
  { destroy(); }  
};

class THash_key : public TObject
  // @author:(INTERNAL) Villa
{
  // @cfriend TAssoc_array
  friend class TIndexed_array;

  // @access:(INTERNAL) Private Member

  // @cmember:(INTERNAL) Chiave d'ordinamento
  TString  _key;
  // @cmember:(INTERNAL) indice 
  int      _index;

  // @access Public Member
public:
  // @cmember Ritorna la chiave di ordinamento
  const TString& key() const { return _key; }
  // @cmember Ritorna l'oggetto
  int index() const { return _index; }

  // @cmember Costruttore (inizializza la chiave ed opzionalmente l'oggetto)
  THash_key(const char* k, int index = -1) : _key(k), _index(index) {}
  // @cmember Distruttore
  virtual ~THash_key() {}
};

// @doc EXTERNAL

// @class TIndexed_array | Array con indice hash
//
// @base public |TObject

class TIndexed_array : public TArray

  // @author:(INTERNAL) Villa

  //@access:(INTERNAL) Private Member
{
  // @cmember:(INTERNAL) Numero di righe della tabella hash
  word _row;
  // @cmember:(INTERNAL) Numero di colonne della tabella hash
  word _col;
  // @cmember:(INTERNAL) Numero di righe della tabella hash per i metodi _item
  int _rowitem;
  // @cmember:(INTERNAL) Numero di colonne della tabella hash per i metodi _item
  int _colitem;
  // @cmember:(INTERNAL) Array contenente i dati veri e propri
  TArray _bucket;

  // @access Protected member
protected:
  TArray& bucket(int index);  // ok
    // @cmember Azzera il numero di riga e colonna corrente della tabella hash
  void restart() { _row = 0; _col = 0; } //ok

  // @cmember Cerca l'oggetto con chiave k
  THash_key * _lookup(const char* k, bool& isnew, bool insert = false); //ok
  // @cmember aggiunge la chiave all'indice
  bool add2index(const char* key, int index = -1, bool force = false); //ok
  // @cmember Copia tutto l'array associativo e ne duplica gli elementi
  TIndexed_array & copy(const TIndexed_array & a); //ok



  // @access Public Member
public:
  // @cmember Duplica l'array associativo copiandone gli elementi.
  virtual TObject* dup() const { return new TIndexed_array(*this); } // ok

  // @cmember Ritorna il nome della classe
  virtual const char* class_name() const;  // ok
  // @cmember Ritorna l'id  della class
  virtual word class_id() const;  // ok
  // @cmember Controlla se si tratta di un oggetto derivato da TArray
  virtual bool is_kind_of(word cid) const; //ok
 
  // @cmember Ritorna l'oggetto nella posizione index
  TObject& operator[] (int index) const; // ok
  // @cmember Ritorna l'oggetto nella posizione index
  virtual TObject* objptr(int index) const; // ok

  //qui
  // @cmember Rimuove uno o tutti (default) gli elementi
  virtual bool destroy(int index = -1, bool pack = false);
  // @cmember Aggiunge un oggetto ad un array.
  virtual int add(TObject* obj, int index = -1) { CHECK(false, "Must specifiy a key"); }
  // @cmember Inserisce un elemento dell'array nella posizione index
  virtual int insert(TObject* obj, int index = 0, bool force = false) { CHECK(false, "Must specifiy a key"); }

  // @cmember Aggiunge un oggetto all'array. L'oggetto viene duplicato
  virtual int add(const TObject& object, int index = -1) { CHECK(false, "Must specifiy a key"); }
  // @cmember Inserisce un oggetto alla posizione index
  virtual int insert(const TObject& object, int index = 0, bool force = false) { CHECK(false, "Must specifiy a key"); }
  // @cmember Elimina l'elemento nella posizione index dell'array
  TObject* remove(int index, bool pack = false);
  // @cmember Elimina l'elemento nella posizione index dell'array
  TObject* remove_item(bool pack = false);
  // @cmember Scambia di posto due elementi dell'array
  void swap(int i1, int i2);
  // @cmember Rende contigui tutti gli elementi non nulli
  virtual void pack();
  // @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 = nullptr, bool force = false); //ok

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

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

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

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

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

  // @cmember Ritorna l'indice del oggetto con chiave key (piu' intuitivo di <mf TAssoc_array::find>)
  TObject& operator[] (const char* key) const { return find(key); }

  // @cmember Ritorna solo l'oggetto
  TObject* get();
  // @cmember Ritorna l'oggetto e la relativa chiave
  THash_key* get_hashkey(); // ok

  bool get_bool(const char* key) const;
  int get_int(const char* key) const;
  const TString& get_str(const char* key) const;

  // @cmember Operatore di assegnamento tra array indicizzati
  TIndexed_array& operator= (const TIndexed_array & a) { return copy(a); }

  // @cmember Costruttori
  TIndexed_array(int arraysize) : TArray(arraysize), _row(0), _col(0) {}
  TIndexed_array() : _row(0), _col(0) {}
  // @cmember Costruttore. Copia tutto l'array indicizzato e ne duplica gli elementi
  TIndexed_array(const TIndexed_array& a) :  _row(0), _col(0) { copy(a);}
  // @cmember Distruttore
  virtual ~TIndexed_array() {}
};

inline TObject* TIndexed_array::objptr(int index) const
{
  THash_object * o = (THash_object *) TArray::objptr(index);

  return (o) ? &(o->obj()) : nullptr;
}

#ifndef DBG
inline TObject& TArray::operator[] (int index) const { return ((THash_obj*)objptr(index))->obj();}
#endif
class TCache : public TObject
{
	TArray _data;

protected:
	virtual void discarding(const THash_object* obj);
  virtual TObject* key2obj(const char* key) pure;

public:
  TObject* objptr(const TString& key);
  TObject* objptr(size_t nkey);
  bool empty() const { return _data.empty(); }
	void destroy();           // Not very useful, but who knows?
  TCache(size_t size = 0);  // 883 assigned by default
	virtual ~TCache();
};

/*
__ass = TAssoc_array da scandire
__obj = variabile del cazzo che serve internamente al ciclo; va nominata e dimenticata
__key = nome della variabile del record corrente dell'Assoc (primo campo)
__str = valore del record corrente dell'Assoc (secondo campo)
Es:
TAssoc_array ass;
TString str;
FOR_EACH_ASSOC_STRING(ass, ho, k, str)
{
  usa in qualche modo k e str presi da ass;
}
*/
#define FOR_EACH_ASSOC_STRING(__ass, __obj, __key, __str)                     \
  const char *__key, *__str; __ass.restart();                                 \
  for (THash_object* __obj = __ass.get_hashobj();                             \
       __obj && ((__str = (const TString&)__obj->obj()) != NULL, __obj && (__key = __obj->key()) != NULL); \
       __obj = __ass.get_hashobj()) 

#define FOR_EACH_ASSOC_OBJECT(__ass, __obj, __key, __itm)                        \
  const char *__key; TObject* __itm; __ass.restart();                            \
  for (THash_object* __obj = __ass.get_hashobj();                                \
       __obj && (__itm = &__obj->obj()) != NULL, __obj && (__key = __obj->key()) != NULL; \
       __obj = __ass.get_hashobj()) 

#endif