campo-sirio/include/array.h

#pragma once
#ifndef __ARRAY_H
#define __ARRAY_H

#ifndef __OBJECT_H
#include <object.h>
#endif

#ifndef NULL
#define NULL 0L
#endif

// @doc EXTERNAL
//
// @type COMPARE_FUNCTION | Prototipo funzione di confronto tra elementi della
//      classe <c TObject> da passare al metodo sort dei <c TArray>
typedef int (*COMPARE_FUNCTION)(const TObject**, const TObject**);
typedef int (*COMPARE_FUNCTION_EX)(const TSortable&, const TSortable&, void*);

// @doc EXTERNAL

// @type CONDITION_FUNCTION | Prototipo funzione di ricerca/filtro
//      per i derivati di <c TObject> da passare ai metodi dei <c TContainer>
typedef bool (*CONDITION_FUNCTION) ( const TObject& );

// @doc EXTERNAL

// @type OPERATION_FUNCTION | Prototipo funzione attuatore 
//      da passare ai metodi sort dei <c TContainer>
typedef void (*OPERATION_FUNCTION) ( const TObject& );


// @doc EXTERNAL

// @class TContainer | Generico contenitore ad accesso casuale (con indice)
// @base public | TObject
class TContainer : public TObject
{

// @author:(INTERNAL) Matteo
  
// @access:(INTERNAL) Private Member
private:
  // @cmember:(INTERNAL) Ultima condizione di ricerca/filtro (vedi <t CONDITION_FUNCTION>)
  CONDITION_FUNCTION _last_condition;    
  
  // @access Public Member
public:
  
  // @cmember Ritorna un puntatore al primo oggetto del contenitore
  virtual TObject* first_item( ) pure;
  // @cmember Ritorna un puntatore all'ultimo oggetto del contenitore
  virtual TObject* last_item( ) pure;
  // @cmember Ritorna un puntatore all'oggetto successivo all'oggetto corrente
  virtual TObject* succ_item( ) pure;
  // @cmember Ritorna un puntatore all'oggetto che precede l'oggetto corrente
  virtual TObject* pred_item( ) pure;
  // @cmember Ritorna il numero di oggetti nel contenitore
  virtual long objects( ) const pure;
  // @cmember Ritorna true se il contenitore e' vuoto
  virtual bool empty() const { return objects( ) == 0; }
  
  // @cmember Cerca il successivo elemento che soddisfa la <t OPERATION_FUNCTION>
  virtual void for_each( OPERATION_FUNCTION );    
  // @cmember Cerca il successivo elemento che soddisfa la <t OPERATION_FUNCTION>
  //          per ogni elemento di <t CONDITION_FUNCTION>
  virtual void for_each_that( OPERATION_FUNCTION, CONDITION_FUNCTION = NULL );
  
  // @cmember Ritorna il puntatore al primo oggetto che soddisfa la condizione
  virtual TObject* first_that( CONDITION_FUNCTION = NULL );
  // @cmember Ritorna il puntatore all'ultimo oggetto che soddisfa la condizione
  virtual TObject* last_that( CONDITION_FUNCTION = NULL );
  // @cmember Ritorna il prossimo oggetto che soddisfa la condizione. Va usata con first_that per scandire il container
  virtual TObject* succ_that( );
  // @cmember Ritorna il precedente oggetto che soddisfa la condizione. Va usata con last_that per scandire il container all'indietro
  virtual TObject* pred_that( );
  // @cmember Ritorna il numero di elementi che soddisfano la condizione
  virtual long count( CONDITION_FUNCTION = NULL );
  // @cmember Ritorna l'oggetto successivo a quello corrente
  TObject* operator++ ()
  { return succ_item( ); }
  // @cmember Ritorna l'oggetto che precede quello corrente
  TObject* operator-- ()
  { return pred_item( ); }

  TContainer() : _last_condition(NULL) {}
  virtual ~TContainer() { }
};

// @doc EXTERNAL

// @class TArray | Classe per la definizione degli array
//
// @base public | TContainer
class TArray : public TContainer

// @author:(INTERNAL) Guido

// @access:(INTERNAL) Private Member
{
  friend class TPointer_array;

  // @cmember:(INTERNAL) Array di puntatori ad oggetti
  TObject** _data;
  // @cmember:(INTERNAL) Dimensione dell'array
  int _size;
  // @cmember:(INTERNAL) Numero di elementi presenti nell'array
  int _items;
  // @cmember:(INTERNAL) Prossimo elemento libero nell'array
  int _next;
  
  // @cmember:(INTERNAL) Indice per la scansione sequenziale
  int _scanindex;
  
  // @access Protected Member
protected:
  TObject** data() const { return _data; }
  
  // @cmember Modifica la dimensione dell'array.
  void resize(int newdim);
  void copy(const TArray& a);

  // @access Public Member
public:
  // @cmember Costruttore. Crea un array (chiama <mf TArray::resize>)
  TArray(int arraysize);
  // @cmember Costruttore. Crea un array (non chiama <mf TArray::resize>)
  TArray();
  // @cmember Costruttore. Copia tutto l'array e ne duplica gli elementi
  TArray(const TArray&);
  
  // @cmember Distruttore
  virtual ~TArray() ;
  // @cmember Ritorna il nome della classe
  virtual const char* class_name() const ;
  // @cmember Ritorna l'id  della class
  virtual word class_id() const ;
  // @cmember Controlla se si tratta di un oggetto derivato da TArray
  virtual bool is_kind_of(word cid) const;
  // @cmember Stampa un array
  virtual void print_on(ostream& out) const ;
  // @cmember Controlla se si tratta di un oggetto valido
  virtual bool ok() const ;

  // @cmember Ritorna la grandezza dell'array
  int size() const
  { return _size; }
  // @cmember Ritorna numero di oggetti nell'array
  virtual long objects( ) const
  { return _items; }

  // @cmember Ritorna numero di oggetti nell'array
  virtual int items() const
  { return _items; }

  // @cmember Ritorna il primo elemento dell'array  
  virtual TObject* first_item( );
  // @cmember Ritorna l'ultimo elemento dell'array
  virtual TObject* last_item( );
  // @cmember Ritorna il successivo elemento dell'array rispetto all'elemento corrente
  virtual TObject* succ_item( );
  // @cmember Ritorna il precedente elemento dell'array rispetto all'elemento corrente
  virtual TObject* pred_item( );
  
  // @cmember Ritorna l'indice del primo oggetto
  int first() const;
  // @cmember Ritorna l'indice dell'ultimo oggetto
  int last() const;
  // @cmember Ritorna l'indice del primo oggetto dopo l'i-esimo
  int succ(int i) const;
  // @cmember Ritorna l'indice del primo oggetto che precede l'i-esimo
  int pred(int i) const;
  
  // @cmember Ritorna l'oggetto nella posizione index
  TObject& operator[] (int index) const ;
  // @cmember Ritorna l'oggetto nella posizione index
  TObject* objptr(int index) const ;
  // @cmember Assegna all'array l'oggetto passato
  TArray& operator=(const TArray& a);

  // @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) ;
  // @cmember Inserisce un elemento dell'array nella posizione index
  virtual int insert(TObject* obj, int index = 0, bool force = false);

  // @cmember Aggiunge un oggetto all'array. L'oggetto viene duplicato
  virtual int add(const TObject& object, int index = -1) ;
  // @cmember Inserisce un oggetto alla posizione index
  virtual int insert(const TObject& object, int index = 0, bool force = false);
  // @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 Ordina i TObject secondo il criterio definito in <t COMPARE_FUNCTION>
  void sort(COMPARE_FUNCTION = NULL);
  void sort(COMPARE_FUNCTION_EX cmp, void* jolly);
};

inline TObject* TArray::objptr(int index) const
{ return (index < _size && index >= 0) ? _data[index] : NULL; }

#ifndef DBG
inline TObject& TArray::operator[] (int index) const
{ return *objptr(index); }
#endif

#define FOR_EACH_ARRAY_ITEM(__arr, __r, __obj)      \
  TObject* __obj;                                   \
  for (int __r = (__arr).first();                   \
       (__obj = (__arr).objptr(__r)) != NULL;       \
       __r = (__arr).succ(__r))

#define FOR_EACH_ARRAY_ITEM_BACK(__arr, __r, __obj) \
  TObject* __obj;                                   \
  for (int __r = (__arr).last();                    \
       (__obj = (__arr).objptr(__r)) != NULL;       \
       __r = (__arr).pred(__r))

TArray& objptr2array(TObject* obj); 

///////////////////////////////////////////////////////////
// TString_array
///////////////////////////////////////////////////////////

#ifndef __STRINGS_H
class TToken_string;
#endif

// @doc EXTERNAL

// @class TString_array | Array di stringhe
//
// @base public | TArray
class TString_array : public TArray
// @author:(INTERNAL) Guido
{
  // @access Public Member
public:
  // @cmember Ritorna la stringa n dell'array (se non c'e' ritorna errore)
  TToken_string& row(int n)
  { return (TToken_string&)operator[](n); }
  // @cmember Ritorna la stringa n dell'array (se non c'e' ritorna errore)
  const TToken_string& row(int n) const
  { return (const TToken_string&)operator[](n); }
  // @cmember Restituisce il puntatore alla stringa n dell'array (NULL se non esiste)
  TToken_string* rowptr(int n)
  { return (TToken_string*)objptr(n); }
  // @cmember assegnamento di un array
  const TString_array& operator=(const TString_array& a);
  // @cmember Aggiunge una Token string all'array (chiama <mf TArray::add>)
  int add(TToken_string* s, int n = -1);
  // @cmember Aggiunge un oggetto stringa all'array (chiama <mf TArray::add>)
  int add(const TToken_string& s, int n = -1);
  // @cmember Aggiunge una stringa all'array (chiama <mf TArray::add>)
  int add(const char* s, int n = -1);
  // @cmember Cerca una stringa nell'array
  int find(const char* s, int from = 0) const;
  // @cmember Ordina alfabeticamente l'array
  void sort(bool ascendig = true);
  // @cmember Ritorna l'ultima riga (deve esistere!)
  TToken_string& last_row() 
  { return (TToken_string&)operator[](last()); }
  
  // @cmember Costruttore
  TString_array(int size = 8) : TArray(size)
  {}
  // @cmember Distruttore
  virtual ~TString_array()
  {}
};

#define FOR_EACH_ARRAY_ROW(__arr, __r, __riga)               \
  TToken_string* __riga;                                     \
  int __r;                              \
  for (__r = (__arr).first();                              \
       (__riga = (TToken_string*)(__arr).objptr(__r));           \
       __r = (__arr).succ(__r))

#define FOR_EACH_ARRAY_ROW_BACK(__arr, __r, __riga)          \
  TToken_string* __riga;                                     \
  int __r;                               \
  for (__r = (__arr).last();                               \
       (__riga = (TToken_string*)(__arr).objptr(__r));           \
       __r = (__arr).pred(__r))

class TPointer_array : public TArray
{
protected:
  void copy(const TArray& a);

public:
  virtual bool destroy(int index = -1, bool pack = false);
  virtual int add(TObject* object, int index = -1);
  virtual int add(const TObject& object, int index = -1);
  virtual int insert(const TObject& object, int index = 0, bool force = false);
  virtual TPointer_array& operator= (const TArray& a) { copy(a); return *this; }
  virtual TPointer_array& operator= (const TPointer_array& a) { copy(a); return *this; }
  
  long get_long(int index) const { return (long)objptr(index); }
  int get_int(int index) const { return (int)get_long(index); }
  int add_long(long value, int index = -1) { return add((TObject*)value, index); }
  int insert_long(long value, int index = -1) { return TArray::insert((TObject*)value, index, true); }
  int find_long(long value) const;
  
  TPointer_array() { }  
  TPointer_array(int size) : TArray(size) { }
  TPointer_array(const TArray& a) { copy(a); }
  TPointer_array(const TPointer_array& a) { copy(a); }
  virtual ~TPointer_array() { destroy(); }
};

// @doc EXTERNAL

// @class TBit_array | Come la classe <c TArray> ma i suoi elementi sono bit;
//                      questo permette di costruire array piu' piccoli rispetto
//                      alla classe TArray.
//
// @base public | TObject
class TBit_array : public TObject

// @author:(INTERNAL) Guido

// @access:(INTERNAL) Private Member
{
  // @cmember:(INTERNAL) dimensione dell'array
  word _size;
  // @cmember:(INTERNAL) bit in cui sono contenuti i dati
  byte* _bit;

  // @access Protected Member
protected:
  // @cmember Controlla se si tratta di un oggetto valido
  virtual bool ok() const;
  // @cmember Stampa un array
  virtual void print_on(ostream& out) const;

  // @cmember Modifica la dimensione dell'array.
  void resize(word size);
  // @cmember Copia nell'array l'elemento passato come parametro
  void copy(const TBit_array& ba);
  // @cmember Ritorna il numero del byte contenente il bit <p n>
  word index(long n) const 
  { return word(n >> 3); }
  // @cmember Ritorna la posizione del bit <p n> all'interno del byte
  byte mask(long n) const 
  { return byte(1 << (n & 0x7)); }

  // @access Public Member
public:
  // @cmember Costruttore. Crea un array di (chiama <mf TBit_array::resize>)
  TBit_array(long size = 0);
  // @cmember Costruttore. Crea un array di (chiama <mf TBit_array::copy>)
  TBit_array(const TBit_array& ba);
  // @cmember Distruttore
  virtual ~TBit_array();

  // @cmember Assegna all'array l'oggetto passato
  TBit_array& operator=(const TBit_array& ba);
  // @cmember Ritorna l'oggetto puntato da n
  bool operator[] (long n) const;
  // @cmember Ritorna l'or logico tra due Bit_array modificando l'oggetto corrente
  TBit_array& operator |=(const TBit_array& b); 

  // @cmember Ritorna il numero di bit nell'array
  long items() const { return 8L * _size; }
  // @cmember Ritorna la posizione del primo 1 nell'array (-1 se non lo trova)
  long first_one() const;
  // @cmember Ritorna la posizione dell'ultimo 1 nell'array (-1 se non lo trova)
  long last_one() const;
  // @cmember Ritorna il numero di 1 presenti nell'array
  long ones() const;
  // @cmember C'<27> almeno un 1
  bool some_one() const;

  // @cmember Setta ad 1 il bit n-esimo dell'array
  void set(long n);
  // @cmember Setta a 0 il bit n-esimo dell'array
  void reset(long n);
  // @cmember Not logico del bit n-esimo dell'array
  void neg(long n);

  // @cmember Setta il bit n-esimo a seconda del valore passato come secondo elemento
  void set(long n, bool on) { on ? set(n) : reset(n); }
  // @cmember Setta ad 1 tutti i bit dell'array
  void set();
  // @cmember Setta a 0 tutti i bit dell'array
  void reset();
  // @cmember Data una stringa setta ad 1 gli elementi indicati della stringa
  void set(const char* numbers);
  // @cmember Data una stringa setta a 0 gli elementi indicati della stringa
  void reset(const char* numbers);
};

#endif