From 50cf15b8ba04530c2810bc6cf2ebcaec8090ee47 Mon Sep 17 00:00:00 2001 From: andrea Date: Wed, 10 May 1995 10:40:40 +0000 Subject: [PATCH] Aggiunta documentazione in linea git-svn-id: svn://10.65.10.50/trunk@1353 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- include/array.cpp | 225 ++++++++++++++++---- include/array.h | 106 ++++++---- include/assoc.cpp | 90 +++++++- include/assoc.h | 108 ++++++---- include/object.h | 156 +++++++++++--- include/strings.cpp | 298 +++++++++++++++++++++++---- include/strings.h | 485 +++++++++++++++++++++++++++++++------------- 7 files changed, 1130 insertions(+), 338 deletions(-) diff --git a/include/array.cpp b/include/array.cpp index 460abab71..855945298 100755 --- a/include/array.cpp +++ b/include/array.cpp @@ -4,18 +4,17 @@ #include // @doc INTERNAL -// -// @mfunc void | TArray | resize | Modifica la dimensione dell'array. -// -// @parm int | newdim | Indica la nuova dimensione che deve assumere l'array. -// -// @comm Alloca la memoria necessaria per contentere i dati della nuova -// dimensione inizializzando a NULL tutti i nuovi elementi aggiunti -// all'array lasciando inalterati, sia in posizione che in -// contenuto gli elementi gia' presenti. -// Nel caso si cerca di diminuire la dimensione viene dato un messaggio -// di errore. -void TArray::resize(int arraysize) + +// @mfunc Modifica la dimensione dell'array. +void TArray::resize( + int arraysize) // @parm Indica la nuova dimensione che deve assumere l'array. + + // @comm Alloca la memoria necessaria per contentere i dati della nuova + // dimensione inizializzando a NULL tutti i nuovi elementi aggiunti + // all'array lasciando inalterati, sia in posizione che in + // contenuto gli elementi gia' presenti. + // Nel caso si cerchi di diminuire la dimensione viene dato un + // messaggio di errore. { CHECK(arraysize > size(), "Can't reduce array size."); @@ -36,22 +35,21 @@ void TArray::resize(int arraysize) // @doc EXTERNAL // -// @mfunc bool | TArray | destroy | Rimuove uno o tutti gli elementi (default) -// -// @parm int |index | Numero dell'elemento da eliminare (default -1) -// @parm bool | pack | Se true richiama la funzione per compattare -// gli elementi dell'array (default FALSE) -// -// @comm Permette la rimozione di uno (index > 0 ) o di tutti (default) gli -// elementi dell'array assegnandone il valore NULL. -// Nel caso il parametro pack sia TRUE permette di rendere contigui tutti -// gli elementi diversi da NULL tramite la chiamata alla funzione . -// -// @rdesc Ritorna uno dei seguenti parametri: -// -// @flag TRUE | Se l'operazione e' riuscita con successo -// @flag FALSE | Se il numero di elementi e' rimasto invariato -bool TArray::destroy(int index, bool pack) +// @mfunc Rimuove uno o tutti (default) gli elementi +bool TArray::destroy( + int index, // @parm Numero dell'elemento da eliminare (default -1) + bool pack) // @parm Se true richiama la funzione per compattare gli elementi dell'array (default FALSE) + + // @comm Permette la rimozione di uno (index > 0 ) o di tutti (default) gli + // elementi dell'array assegnandone il valore NULL. + // Nel caso il parametro pack sia TRUE permette di rendere contigui + // tutti gli elementi diversi da NULL tramite la chiamata alla funzione + // . + // + // @rdesc Ritorna uno dei seguenti parametri: + // + // @flag TRUE | Se l'operazione e' riuscita con successo + // @flag FALSE | Se il numero di elementi e' rimasto invariato { const int old = _items; @@ -119,8 +117,14 @@ word TArray::class_id() const return CLASS_ARRAY; } -//ANDREA -void TArray::print_on(ostream& out) const +// @mfunc Stampa un array +void TArray::print_on( + ostream& out) const // @parm indica l'output sul quale reindirizzare la stampa (funzione standard del C++) + + // @comm Permette di stampare sull'output passato come parametro il contenuto + // dell'array, preceduto dal numero dell'elemetno a cui si riferisce. + // Nel caso vi siano degli elementi vuoti (valore = NULL) viene + // stampato il valore (null). { for (int i = 0; i < size(); i++) @@ -134,15 +138,43 @@ void TArray::print_on(ostream& out) const } } - +// @mfunc Controlla se si tratta di un oggetto valido bool TArray::ok() const +// @rdesc Ritorna uno dei seguenti parametri: +// +// @flag TRUE | Se l'array contiene degli elementi +// @flag FALSE | Se l'array e' vuoto +// +// @comm Controlla se la dimensione dell'array e' uguale a 0 e se esistono +// degli elementi diversi da NULL + { return(size() != 0 && (_data != NULL)); } +// @mfunc Aggiunge un oggetto ad un array. +int TArray::add( + TObject *object, // @parm Oggetto da aggiungere nell'array + int index) // @parm Posizione in cui aggiungere l'oggetto + // @parm TObject | &object | Oggetto da aggiungere nell'array. L'oggetto viene duplicato -int TArray::add(TObject* object, int index) + // @syntax add(TObject* object,int index); + // @syntax add(TObject& object,int index); + // + // @comm Nel caso venga passata una posizione minore di 0 l'elemento viene aggiunto + // in coda all'array, diversamente viene l'elemento presente viene + // sostitito con l'oggetto passato nei prametri. + // Se e' stato passato un indice minore della dimensione dell'array, + // viene aumentata automaticamente la dimensione dell'array stesso tramite + // la chiamata alla funzione . + // ATTENZIONE: Nel caso si passi l'oggetto per indirizzo deve + // essere definita la funzione . + // + // @rdesc La funzione ritorna la posizione nella quale e' stato aggiunto + // l'oggetto. + // + // @xref { if (index < 0) for (index = 0; index < size() && _data[index]; index++); if (index >= size()) resize(3*index/2 + 1); @@ -166,8 +198,25 @@ int TArray::add(TObject* object, int index) return index; } +// @mfunc Inserisce un elemento dell'array nella posizione index +int TArray::insert( + TObject *object, // @parm Oggetto da inserire nell'array + int index) // @parm Posizione in cui inserire l'oggetto + // @parm TObject | &object | Oggetto da inserire nell'array. L'oggetto viene duplicato -int TArray::insert(TObject* object, int index) + // @syntax insert(TObject* object, int index); + // @syntax insert(TObject& object, int index); + // + // @comm Nel caso l'elemento della posizione passata sia diverso da NULL vengono + // spostati di una posizione tutti gli elementi presenti nell'array. + // La dimensione dell'array viene automaticamente aumentata nel caso + // la stessa non sia sufficiente a contenere il nuovo oggetto. + // ATTENZIONE: Nel caso si passi l'oggetto per indirizzo deve + // essere definita la funzione . + // + // @rdesc La funzione ritorna la posizione nella quale e' stato inserito l'oggetto. + // + // @xref { if (objptr(index)) { @@ -179,6 +228,7 @@ int TArray::insert(TObject* object, int index) return add(object, index); } + int TArray::add(const TObject& object, int index) { TObject* objptr = object.dup(); @@ -191,7 +241,13 @@ int TArray::insert(const TObject& object, int index) return insert(objptr, index); } -TObject* TArray::remove(int index, bool dopack) +// @mfunc Elimina l'elemento nella posizione index dell'array +TObject* TArray::remove( + int index, // @parm Indica la posizione dell'elemento da eliminare + bool dopack) // @parm Indica se si vuole richiamare la funzione + // (default FALSE) per il compattamento dell'array + + // @rdesc Ritorna l'elemento dell'array eliminato { TObject* o = objptr(index); if (o) @@ -218,8 +274,11 @@ int TArray::last() const return last; } - +// @mfunc Rende contigui tutti gli elementi non nulli void TArray::pack() + + // @comm Riordina gli elementi dell'array facendo che tra di loro non ve ne + // siano con valore uguale a NULL. { int next = 0; for (int i = 0; i < size(); i++) @@ -236,15 +295,32 @@ void TArray::pack() } } +// @func Funzione per permettere il confonto tra 2 oggetti. +// +// @rdesc Ritorna i seguenti valori +// +// @flag 0 | se

+// @flag 0 | se

==

+// @flag 0 | se

+// @flag UNDEFINED | se l'ordine non e' definito +static int sortable_compare( + const TObject** o1, // @parm Primo oggetto da confrontare + const TObject** o2) // @parm Secondo oggetto da confrontare -static int sortable_compare(const TObject** o1, const TObject** o2) + // @comm E' utilizzata dalla funzione come default per + // stabilire il criteri di ordinamento degli oggetti passati. { const TSortable* s1 = (const TSortable*)*o1; const TSortable* s2 = (const TSortable*)*o2; return s1->compare(*s2); } -void TArray::sort(COMPARE_FUNCTION compare) +// @mfunc Ordina i TObject secondo il criterio definito in +void TArray::sort( + COMPARE_FUNCTION compare) // @parm Funzione indicante il criterio di ordinamento (default TSortable) + + // @comm Nel caso non venga passata nessuna funzione che permetta di conforntare + // i due oggetti viene utilizzato il criterio { typedef int (*qsortfunc)(const void*, const void*); if (compare == NULL) compare = sortable_compare; @@ -262,7 +338,13 @@ TBit_array::TBit_array(long size) : _bit(NULL), _size(0) if (size) resize(index(size)); } -void TBit_array::copy(const TBit_array& ba) +// @doc INTERNAL +// +// @mfunc Copia nell'array l'elemento passato come parametro +void TBit_array::copy( + const TBit_array& ba) // @parm Oggetto da copiare nell'array + + // @comm Sostituisce all'elemento corrente dell'array l'elemento passato come parametro. { if (_bit) { @@ -302,7 +384,16 @@ void TBit_array::reset() } // Certified 99% -void TBit_array::resize(word size) +// @doc INTERNAL +// +// @mfunc Modifica la dimensione dell'array. +void TBit_array::resize( + word size) // @parm Indica la nuova dimensione che deve assumere l'array. + + // @comm Alloca la memoria necessaria per contentere i dati della nuova + // dimensione inizializzando a NULL tutti i nuovi elementi aggiunti + // all'array lasciando inalterati, sia in posizione che in + // contenuto gli elementi gia' presenti. { word oldsize = _size; byte* oldbit = _bit; @@ -361,8 +452,18 @@ void TBit_array::not(long n) _bit[i] ^= mask(n); } -// Certified 50% +// Certified 90% +// @doc EXTERNAL +// +// @mfunc Ritorna il numero di 1 presenti nell'array long TBit_array::ones() const + +// @rdesc Numero di 1 trovati. +// +// @comm Passa tutto l'array di bit e conta quanti degli elementi presenti sono +// settati ad 1. +// +// @xref { long one = 0; for (word i = 0; i < _size; i++) @@ -378,7 +479,20 @@ long TBit_array::ones() const } // Certified 90% +// @doc EXTERNAL +// +// @mfunc Ritorna la posizione dell'ultimo 1 nell'array long TBit_array::last_one() const + +// @rdesc Ritorna i seguenti valori: +// +// @flag >0 | Posizione nella quale si trova l'ultimo 1 +// @flag -1 | Se non sono presenti bit settati ad 1 +// +// @comm Cerca all'interno dell'array di bit la posizione dell'ultimo bit +// settato ad 1 +// +// @xref { for (word i = _size; i--;) { @@ -393,7 +507,18 @@ long TBit_array::last_one() const } // Certified 90% +// @mfunc Ritorna la posizione del primo 1 nell'array long TBit_array::first_one() const + +// @rdesc Ritorna i seguenti valori: +// +// @flag >0 | Posizione nella quale si trova il primo 1 +// @flag -1 | Se non sono presenti bit settati ad 1 +// +// @comm Cerca all'interno dell'array di bit la posizione del primo bit +// settato ad 1 +// +// @xref { for (word i = 0; i < _size; i++) { @@ -407,7 +532,18 @@ long TBit_array::first_one() const return -1; } +// @doc INTERNAL +// +// @mfunc Controlla se si tratta di un oggetto valido bool TBit_array::ok() const + +// @rdesc Ritorna uno dei seguenti parametri: +// +// @flag TRUE | Se l'array contiene degli elementi +// @flag FALSE | Se l'array e' vuoto +// +// @comm Controlla se la dimensione dell'array e' maggiore di 0 e se esistono +// degli elementi diversi da NULL { return _bit != NULL && _size > 0; } @@ -420,12 +556,17 @@ void TBit_array::set(const char* numbers) if (isdigit(*n)) set(atol(n)); } +// @doc INTERNAL +// +// @mfunc Stampa un array +void TBit_array::print_on( + ostream& out) const // @parm Indica l'output sul quale reindirizzare la stampa (funzione standard del C++) -void TBit_array::print_on(ostream& out) const + // @comm Stampa tutti gli indici degli elementi diversi da 0 { const long last = _size<<3; for (long i = 1; i < last; i++) - if (operator[](i)) out << ' ' << i; + if (operator[](i)) out << ' ' << i; } diff --git a/include/array.h b/include/array.h index 57b3e51ed..375f6cf07 100755 --- a/include/array.h +++ b/include/array.h @@ -15,87 +15,86 @@ class TArray; // // @type COMPARE_FUNCTION | Prototipo funzione di confronto tra elementi della // clsse da passare al metodo sort dei - typedef (*COMPARE_FUNCTION)(const TObject**, const TObject**); // @class TArray | Classe per la definizione degli array // // @base public | TObject - class TArray : public TObject { // @access Private Member - TObject** _data; // @cmember TObject** | _data | | Array di puntatori ad oggetti - int _size; // @cmember int | _size | | Dimensione dell'array - int _items; // @cmember int |_items | | Numero di elementi presenti nell'array + // @cmember Array di puntatori ad oggetti + TObject** _data; + // @cmember Dimensione dell'array + int _size; + // @cmember Numero di elementi presenti nell'array + int _items; // @access Protected Member - protected: - // @cmember void | resize | (int newdim) | Modifica la dimensione dell'array. + // @cmember Modifica la dimensione dell'array. void resize(int newdim); - // @access Public member - + // @access Public Member public: - // @cmember void | TArray | (int arraysize) | Costruttore. Crea un array (chiama ) + // @cmember Costruttore. Crea un array (chiama ) TArray(int arraysize); - // @cmember void | TArray | ( ) | Costruttore. Crea un array (non chiama ) + // @cmember Costruttore. Crea un array (non chiama ) TArray(); - // @cmember void | TArray | (const TArray&) | Costruttore. Copia tutto l'array e ne duplica gli elementi + // @cmember Costruttore. Copia tutto l'array e ne duplica gli elementi TArray(const TArray&); - // @cmember virtual | ~TArray | () | Distruttore + // @cmember Distruttore virtual ~TArray() ; - // @cmember virtual const char * | class_name | () const | Ritorna il nome della classe + // @cmember Ritorna il nome della classe virtual const char* class_name() const ; - // @cmember virtual word | class_id | () const | Ritorna l'id della class + // @cmember Ritorna l'id della class virtual word class_id() const ; - // @cmember virtual void | print_on | (ostream& out) const | Stampa un array + // @cmember Stampa un array virtual void print_on(ostream& out) const ; - // @cmember virtual bool | ok | () const | TRUE se l'array non e' vuoto + // @cmember Controlla se si tratta di un oggetto valido virtual bool ok() const ; - // @cmember int | size | () const | Ritorna la grandezza dell'array - int size() const { return _size; } - // @cmember int | items | () const | Ritorna numero di oggetti nell'array - int items() const { return _items; } - // @cmember int | last | () const | Ritorna l'indice dell'ultimo oggetto + // @cmember Ritorna la grandezza dell'array + int size() const + { return _size; } + // @cmember Ritorna numero di oggetti nell'array + int items() const + { return _items; } + // @cmember Ritorna l'indice dell'ultimo oggetto int last() const; - // @cmember TObject& | operator[] | (int index) const | Ritorna l'oggetto puntato da index + // @cmember Ritorna l'oggetto puntato da index TObject& operator[] (int index) const ; - // @cmember TObject* | objptr | () const | Ritorna l'oggetto di posto index + // @cmember Ritorna l'oggetto di posto index TObject* objptr(int index) const ; - // @cmember Tarray& | operator= | (const TArray& a) | Confronta se i due array sono uguali + // @cmember Assegna all'array l'oggetto passato TArray& operator= (const TArray& a); - // @cmember virtual bool | destroy | (int index, bool pack) | Rimuove uno o tutti gli elementi (default) + // @cmember Rimuove uno o tutti (default) gli elementi virtual bool destroy(int index = -1, bool pack = FALSE); - // @cmember virtual int | add | (TObject* obj, int index) | Aggiunge un oggetto ad un array. + // @cmember Aggiunge un oggetto ad un array. virtual int add(TObject* obj, int index = -1) ; - // @cmember virtual int | insert | (TObject* obj, int index) | Inserisce un elemento dell'array nella poszione index + // @cmember Inserisce un elemento dell'array nella posizione index virtual int insert(TObject* obj, int index = 0); - // (casino se non ha dup() definita) - // @cmember int | add | (const TObject& object, int index) | Aggiunge un oggetto all'array. L'oggetto viene duplicato + // @cmember Aggiunge un oggetto all'array. L'oggetto viene duplicato int add(const TObject& object, int index = -1) ; - // @cmember int | insert | (const TObject& object, int index) | Inserisce un oggetto alla posizione index + // @cmember Inserisce un oggetto alla posizione index int insert(const TObject& object, int index = 0); - // @cmember TObject* | remove | (int index, bool pack) | Elimina l'elemento nella poszione index dell'array + // @cmember Elimina l'elemento nella posizione index dell'array TObject* remove(int index, bool pack = FALSE); - // @cmember void | swap | (int i1, int i2) | Scambia di posto gli elemnti i1 e i2 dell'array + // @cmember Scambia di posto due elementi dell'array void swap(int i1, int i2); - // @cmember void | pack | () | Rende contigui tutti gli elementi non nulli + // @cmember Rende contigui tutti gli elementi non nulli void pack(); - // @cmember void | sort | (COMPARE_FUNCTION) | Ordina i TObject (TSortable per default) secondo il criterio definito in + // @cmember Ordina i TObject secondo il criterio definito in void sort(COMPARE_FUNCTION = NULL); }; -//ANDREA inline TObject* TArray::objptr(int index) const { return (index < _size && index >= 0) ? _data[index] : NULL; @@ -110,41 +109,74 @@ inline TObject& TArray::operator[] (int index) const #endif return *o; } - +// @class TBit_array | Come la classe 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 { + + // @access Private Member + + // @cmember dimensione dell'array word _size; + // @cmember 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 n word index(long n) const { return word(n >> 3); } + // @cmember Ritorna la posizione del bit n all'interno del byte byte mask(long n) const { return 1 << (n & 0x7); } + // @access Public Member public: + // @cmember Costruttore. Crea un array di (chiama ) TBit_array(long size = 0); + // @cmember Costruttore. Crea un array di (chiama ) 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 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 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 not(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); }; diff --git a/include/assoc.cpp b/include/assoc.cpp index 215c4644a..898126014 100755 --- a/include/assoc.cpp +++ b/include/assoc.cpp @@ -1,6 +1,21 @@ #include -THash_object* TAssoc_array::_lookup(const char* k, bool& isnew, bool insert) +// @doc EXTERNAL + +// @mfunc Cerca l'oggetto con chiave

+THash_object* TAssoc_array::_lookup( + const char* k, // @parm Chiave da cercare + bool& isnew, // @parm Viene asseganto TRUE se si tratta di una nuova chiave + bool insert) // @parm Permette di inserire la chiave + + // @comm Ricerca all'interno della tabella hash l'oggetto con la chiave

, + // nel caso non venga trovato

ritorna TRUE (si tratta di un + // oggetto nuovo) e viene inserito nella tabella se il parametro

+ // e' settato a TRUE. + // + // @rdesc Ritorna l'oggetto corrispondente alla chiave passate come parametro. + // Il parametro

assume il valore TRUE se si tratta di un + // nuovo oggetto. { const TFixed_string key(k); const word hv = key.hash() % HASH_SIZE; @@ -35,8 +50,25 @@ void TAssoc_array::destroy() _cnt = _row = _col = 0; } -bool TAssoc_array::add(const char* key, TObject* obj, - bool force) +// @mfunc Aggiunge un oggetto all'array. +bool TAssoc_array::add( + const char* key, // @parm Chiave d'ordinamento + TObject* obj, // @parm Ogetto da inserire (default=NULL) + bool force) // @parm Permette di forzare l'inserimento se esiste gia' + // un oggetto con la stessa chiave + + // @parm const TObject | &obj | Indirizzo dell'oggetto da aggiungere + // + // @syntax add(const char* key, TObject* obj, bool force) + // @syntax add(const char* key, const TObject& obj, bool force) + // + // @comm Se l'oggetto da aggiungere esite gia' la chiave guarda il parametro

: + // se

= TRUE lo sostituisce e ritorna TRUE, + // se

= FALSE non sostituisce e ritorna TRUE, + // altrimenti ritorna FALSE. + // Nel caso l'oggetto da aggiungere venga passato per indirizzo + // la funzione aggiunge una copia dell'oggetto e quindi deve essere + // definita { bool isnew = FALSE; @@ -61,7 +93,16 @@ bool TAssoc_array::add(const char* key, const TObject& obj, bool force) return add(key,obj.dup(),force); } -bool TAssoc_array::remove(const char* k) +// @mfunc Elimina un oggetto. +bool TAssoc_array::remove( + const char* k) // @parm Chiave dell'oggetto da eliminare + + // @comm Cerca nella tabella hash l'oggetto con chiave

e lo elimina. + // + // @rdesc Ritorna il risultato dell'operazione + // + // @flag TRUE | Eliminazione avvenuta + // @flag FALSE | L'oggetto non e' stato trovato { const TFixed_string key(k); const word hv = key.hash() % HASH_SIZE; @@ -81,7 +122,16 @@ bool TAssoc_array::remove(const char* k) return FALSE; } -TObject& TAssoc_array::find(const char* key) +// @mfunc Trova l'oggetto indicizzato +TObject& TAssoc_array::find( + const char* key) // @parm Chiave dell'oggetto da trovare + + + // @comm Cerca l'oggetto indicizzato con chiave

. Viene controllato se + // non c'e' (normalmente si usa operator[key]) + // + // @rdesc Ritorna l'oggetto cercato. Se l'oggetto aggiunto era NULL + // ritorna error object { bool isnew = FALSE; THash_object* o = _lookup(key, isnew); @@ -90,7 +140,11 @@ TObject& TAssoc_array::find(const char* key) else return *(o->_obj); } -TObject* TAssoc_array::objptr(const char* key) +// @mfunc Ritorna l'oggetto con chiave

+TObject* TAssoc_array::objptr( + const char* key) // @parm Chiave dell'oggetto da ritornare + + // @rdesc Se l'oggetto esiste ne ritorna il puntatore, altrimenti ritorna NULL { bool isnew; THash_object* o = NULL; @@ -99,7 +153,14 @@ TObject* TAssoc_array::objptr(const char* key) return NULL; } -bool TAssoc_array::is_key(const char* key) +// @mfunc Controlla l'esistenza di una chiave +bool TAssoc_array::is_key( + const char* key) // @parm Chiave da cercarne l'esistenza + + // @rdesc Ritorna il risultato della ricerca + // + // @flag TRUE | Se la chiave esiste + // @flag FALSE | Se la chiave non esiste { bool isnew = FALSE; const THash_object* o = _lookup(key, isnew); @@ -107,7 +168,13 @@ bool TAssoc_array::is_key(const char* key) return TRUE; } +// @mfunc Ritorna solo l'oggetto TObject* TAssoc_array::get() + + // @rdesc Ritorna il puntatore all'oggetto (se diverso da NULL), altrimenti + // ritorna error object + // + // @xref { const TArray* arr = &_data[_row]; @@ -125,7 +192,15 @@ TObject* TAssoc_array::get() return (o == NULL || o->_obj == NULL) ? &error : o->_obj; } +// @mfunc Ritorna l'oggetto e la relativa chiave THash_object* TAssoc_array::get_hashobj() + + // @comm Se l'oggetto viene trovato viene richiamata la funzione + // + // + // @rdesc Se l'oggetto esiste ne ritorna il puntatore, altrimenti ritorna NULL + // + // @xref { const TArray* arr = &_data[_row]; @@ -141,4 +216,3 @@ THash_object* TAssoc_array::get_hashobj() return (THash_object*)arr->objptr(_col++); } - diff --git a/include/assoc.h b/include/assoc.h index 174275099..a18ae91e2 100755 --- a/include/assoc.h +++ b/include/assoc.h @@ -5,83 +5,117 @@ #include #endif +// @doc EXTERNAL +// +// @class THash_object | Classe per la definizione degli elementi di una tabella +hash. Ha come classe friend la classe +// +// @base public | TObject class THash_object : public TObject { 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: - TString& key() { return _key; } - TObject& obj() { return *_obj; } + // @cmember Ritorna la chiave di ordinamento + TString& key() + { return _key; } + // @cmember Ritorna l'oggetto + TObject& obj() + { return *_obj; } - THash_object(const char* k) : _key(k) {} - ~THash_object() { if (_obj != NULL) delete _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 { - enum { HASH_SIZE = 113 }; - word _cnt; - word _row; - word _col; - TArray _data[HASH_SIZE]; + + //@access Private Member + + // @cmember 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]; -protected: + // @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: - int items() const { return _cnt; } + // @cmember Ritorna il numero di elementi presenti + int items() const + { return _cnt; } + + // @cmember Cancella tutti gli elementi virtual void destroy(); - // aggiunge oggetto; Se c'era gia' la chiave guarda force: - // se force = TRUE lo sostituisce e ritorna TRUE - // se force = FALSE non sostituisce e ritorna TRUE - // altrimenti ritorna FALSE + // @cmember Aggiunge un oggetto. Se era gia' presente guarda il parametro force bool add(const char* key, TObject* obj = NULL, bool force = FALSE); - // aggiunge copia oggetto (deve avere dup()). Vedi l'altra - // per i parametri + // @cmember Aggiunge una copia dell'oggetto bool add(const char* key, const TObject& obj, bool force = FALSE); - // elimina oggetto; ritorna FALSE se non c'era + // @cmember Elimina un oggetto bool remove(const char* key); - // trova oggetto indicizzato; check se non c'e' - // normalmente si usa operator[key] - // se l'oggetto aggiunto era NULL ritorna error object + // @cmember Trova l'oggetto indicizzato TObject& find(const char* key); - // ritorna puntatore o NULL + // @cmember Ritorna l'oggetto con chiave key TObject* objptr(const char* key); - // TRUE se la chiave c'e', FALSE altrimenti - bool is_key(const char* key); + // @cmember Controlla l'esistenza di una chiave + bool is_key(const char* key); - // l'indice e' un po' strano ma si usera' questa poiche' - // 1) e' intuitivo - // 2) fa molto figo - TObject& operator[] (const char* key) { return find(key); } + // @cmember Ritorna l'indice del oggetto con chiave key (pi— intuitivo di + // + 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) - TObject* get(); // ritorna solo l'object - THash_object* get_hashobj(); // se serve anche la chiave - 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(); + // @cmember Azzera il numero di righe e colonne della tabella hash + void restart() + { _row = 0; _col = 0; } - TAssoc_array() : _cnt(0), _row(0), _col(0) {} + // @cmember Costruttore + TAssoc_array() : _cnt(0), _row(0), _col(0) + {} + // @cmember Distruttore virtual ~TAssoc_array() { destroy(); } }; - - #endif - - - diff --git a/include/object.h b/include/object.h index df3e4250d..545cfa90b 100755 --- a/include/object.h +++ b/include/object.h @@ -16,62 +16,81 @@ #ifndef __CHECKS_H #include #endif -// @C -// Classe Object -// @END - -// @N -// Base class for all object hierarchy -// @END ////////////////////////////////////////////////////////////////////////////// // Object ////////////////////////////////////////////////////////////////////////////// + +// @doc EXTERNAL +// +// @class TObject | Classe base per la definizione della gerarchia degli oggetti class TObject { + // @access Public Member public: - // @FPUB - virtual ~TObject() {} + // @cmember Distruttore + virtual ~TObject() + {} + // @cmember Ritorna il nome della classe virtual const char* class_name() const; + // @cmember Ritorna l'id della classe virtual word class_id() const; + // @cmember Controlla se si tratta di un oggetto valido (sempre TRUE) virtual bool ok() const; + // @cmember Duplica un'oggetto virtual TObject* dup() const; + // @cmember Permette di stampare l'oggetto virtual void print_on(ostream& out) const; - virtual void read_from(istream&) {} - virtual word hash() const { return 0; } + // @cmember Permette di leggere l'oggetto da istream + virtual void read_from(istream&) + {} + // @cmember Ritorna il codice hash dell'oggetto + virtual word hash() const + { return 0; } }; -// @C -// Classe TErrorObject -// @END - ////////////////////////////////////////////////////////////////////////////// // Error Object ////////////////////////////////////////////////////////////////////////////// + +// @class TError_Object | Classe per poter ritornare un oggetto sempre errato (ok() == false) +// +// @base public | TObject class TError_Object : public TObject { + // @access Public Member public: - // @FPUB + // @cmember Ritorna il nome dell'oggetto virtual const char* class_name() const; + // @cmember Ritorna l'id della classe virtual word class_id() const; + // @cmember Controlla se si tratta di un oggetto valido (sempre FALSE) virtual bool ok() const; + + // @xref }; -// @C -// Classe TSortable -// @END - ////////////////////////////////////////////////////////////////////////////// // Error Object ////////////////////////////////////////////////////////////////////////////// +// @class TSortable | Classe per la comparazione degli oggetti +// +// @base public | TObject class TSortable : public TObject { + // @access Public Memebr public: - // @FPUB + // @cmember Permette la comparazione degli oggetti + // Ritorna: 0 se

+ // 0 se

==

+ // 0 se

+ // UNDEFINED se l'ordine non e' definito virtual int compare(const TSortable& s) const pure; + // @cmember Ritorna il nome della classe virtual const char* class_name() const; + // @cmember Ritorna l'id della classe virtual word class_id() const; }; @@ -80,58 +99,131 @@ public: // inline functions ////////////////////////////////////////////////////////////////////////////// -// @FIN -inline ostream& operator <<(ostream& out, const TObject& obj) +// @func inline ostream& | operator | Permette di reindirizzare l'oggeto per la stampa +inline ostream& operator <<( + ostream& out, // @parm Indica l'output sul quale stampare l'oggetto + const TObject& obj) // @parm Oggetto da stampare + + // @rdesc Ritorna l'output sul quale e' stata reindirizzata la stampa { obj.print_on(out); return out; } -// @FIN -inline istream& operator >>(istream& in, TObject& obj) +// @func inline istream& | operator | Permette di leggere l'oggetto +inline istream& operator >>( + istream& in, // @parm Input da cui leggere l'oggetto + TObject& obj) // @parm Indirizzo in cui posizionare l'oggetto letto + + // @rdesc Ritorna l'input dal quale e' stato letto l'oggetto + // + // @comm Legge dall'input passato come parametro l'oggetto, nel caso si tratti + // di un oggetto on valido viene dato un messaggio di errore. { obj.read_from(in); CHECK(obj.ok(), "Can't read an Object from a stream"); return in; } -inline bool operator ==(const TSortable& a, const TSortable& b) +// @func inline bool | operator == | Controlla se 2 oggetti sono uguali +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se i due oggetti sono uguali +// @flag FALSE | Se i due oggetti sono diversi +inline bool operator ==( + const TSortable& a, // @parm Primo oggetto da confrontare + const TSortable& b) // @parm Secondo oggetto da confrontare + + // @comm Controlla se i due oggetti passati come parametro sono uguali + // utilizzando il criterio di comparazione previsto per l'oggetto. { int res = a.compare(b); return res == 0 || res == UNDEFINED; } -inline bool operator >(const TSortable& a, const TSortable& b) +// @func inline bool | operator | Controlla se un oggetto e' maggiore dell'altro +inline bool operator >( + const TSortable& a, // @parm Primo oggetto da confrontare + const TSortable& b) // @parm Secondo oggetto da confrontare + // @rdesc Ritorna i seguenti valori + // + // @flag TRUE | Se

e' maggiore di

+ // @flag FALSE | Se

e' maggiore o uguale a

+ // + // @comm Controlla se l'oggetti passato come primo parametro e' maggiore del + // secondo utilizzando il criterio di comparazione previsto per l'oggetto. { int res = a.compare(b); return res > 0 || res == UNDEFINED; } -inline bool operator <(const TSortable& a, const TSortable& b) +// @func inline bool | operator | Controlla se un oggetto e' minore dell'altro +inline bool operator <( + const TSortable& a, // @parm Primo oggetto da confrontare + const TSortable& b) // @parm Secondo oggetto da confrontare + // @rdesc Ritorna i seguenti valori + // + // @flag TRUE | Se

e' minore di

+ // @flag FALSE | Se

e' minore o uguale a

+ // + // @comm Controlla se l'oggetti passato come primo parametro e' minore del + // secondo utilizzando il criterio di comparazione previsto per l'oggetto. { int res = a.compare(b); return res < 0 || res == UNDEFINED; } -inline bool operator >=(const TSortable& a, const TSortable& b) +// @func inline bool | operator = | Controlla se un oggetto e' maggiore o uguale all'altro +inline bool operator >=( + const TSortable& a, // @parm Primo oggetto da confrontare + const TSortable& b) // @parm Secondo oggetto da confrontare + // @rdesc Ritorna i seguenti valori + // + // @flag TRUE | Se

e' maggiore o uguale a

+ // @flag FALSE | Se

e' maggiore

+ // + // @comm Controlla se l'oggetti passato come primo parametro e' maggiore o uguale al + // secondo utilizzando il criterio di comparazione previsto per l'oggetto. { int res = a.compare(b); return res >= 0 || res == UNDEFINED; } -inline bool operator <=(const TSortable& a, const TSortable& b) +// @func inline bool | operator = | Controlla se un oggetto e' minore o uguale all'altro +inline bool operator <=( + const TSortable& a, // @parm Primo oggetto da confrontare + const TSortable& b) // @parm Secondo oggetto da confrontare + // @rdesc Ritorna i seguenti valori + // + // @flag TRUE | Se

e' minore o uguale a

+ // @flag FALSE | Se

e' minore

+ // + // @comm Controlla se l'oggetti passato come primo parametro e' minore o uguale al + // secondo utilizzando il criterio di comparazione previsto per l'oggetto. { int res = a.compare(b); return res <= 0 || res == UNDEFINED; } -inline bool operator !=(const TSortable& a, const TSortable& b) +// @func inline bool | operator != | Controlla se 2 oggetti sono diversi +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se i due oggetti sono diversi +// @flag FALSE | Se i due oggetti sono uguali +inline bool operator !=( + const TSortable& a, // @parm Primo oggetto da confrontare + const TSortable& b) // @parm Secondo oggetto da confrontare + + // @comm Controlla se i due oggetti passati come parametro sono diversi + // utilizzando il criterio di comparazione previsto per l'oggetto. { int res = a.compare(b); return res != 0 && res != UNDEFINED; @@ -141,9 +233,7 @@ inline bool operator !=(const TSortable& a, const TSortable& b) #define extern #endif -// @DPUB extern TError_Object error; -// @END #undef extern diff --git a/include/strings.cpp b/include/strings.cpp index e0212c530..99a7c4508 100755 --- a/include/strings.cpp +++ b/include/strings.cpp @@ -58,10 +58,16 @@ HIDDEN TString512 spark; inline bool is_space(char c) { return c >= '\t' && c <= ' '; } -// Dinamically resizes a string // Certified 99% -// It doesn't work for static strings and negative values of size -void TString::resize(int size, bool cpy) +// @doc EXTERNAL +// +// @mfunc Rialloca la stringa +void TString::resize( + int size, // @parm Nuova dimensione della stringa + bool cpy) // @parm Se TRUE mantiene il contenuto della stringa e alloca + // nuovo spazio + + // @comm Non funzione con le stringhe static e per valori negativi di

{ char* s = new char[size+1]; if (cpy && _str) strcpy(s, _str); @@ -74,9 +80,15 @@ void TString::resize(int size, bool cpy) _size = size; } -// Set the value for the string // Certified 99% (uses resize) -TString& TString::set(const char* s) +// @doc INTERNAL +// +// @mfunc Inizializza con la stringa puntata da char* di lunghezza size +// (usa ) +TString& TString::set( + const char* s) // @parm Stringa da inizializzare + + // @rdesc Ritorna l'indirizzo della stringa inizializzata { if (s == NULL) s = ""; const int sz = *s ? strlen(s) : 7; @@ -86,16 +98,24 @@ TString& TString::set(const char* s) return *this; } -// Eventually expands the string for s more chars -int TString::make_room(int s) +// @mfunc Espande la stringa per altri caratteri +int TString::make_room( + int s) // @parm Numero di caratteri di cui si cuole aspandere la stringa + + // @comm La stringa viene espansa di un numero di caratteri doppio (per sicurezza) di + // quello passato per parametro + // + // @rdesc Ritorna il numero di caratteri della stringa prima della chiamata { const int lun = len(); const int spare = size() - lun; if (spare < s) - resize(size() + 2*s, TRUE); // Melius abundare ... + resize(size() + 2*s, TRUE); return lun; } +// @doc EXTERNAL + TString::TString(const char* s) : _str(NULL), _size(0) { set(s); } @@ -171,7 +191,10 @@ TString& TString::operator <<(const TString& str) { return operator <<(str._str); } -TString& TString::strip(const char* k) +// @mfunc Elimina tutti i caratteri contenuti in

+TString& TString::strip( + const char* k) // @parm Stringa da controllarne l'esitenza nell'oggetto + { int j = 0; for (int i = 0; _str[i]; i++) @@ -219,7 +242,12 @@ const char* TString::class_name() const word TString::class_id() const { return CLASS_STRING; } +// @mfunc Duplica una stringa TObject* TString::dup() const + +// @comm Alloca nuovo spazio per duplicare la stringa +// +// @rdesc Ritorna il puntatore alla stringa duplicata { TString* s = new TString(size()); s->set(_str); @@ -240,7 +268,23 @@ void TString::print_on(ostream& out) const // Certified 100% -int TString::find(char c, int from) const +// @mfunc Ritorna la posizione del carattere o della stringa nell'oggetto TString +// +// @rdesc Ritorna i seguneti parametri: +// +// @flag = 0 | Posizione dell'elemento nella stringa +// @flag -1 | L'elemento non e' stato trovato +int TString::find( + char c, // @parm Carattere da cercare + int from) const // @parm Posizione da cui iniziare la ricerca + // @parm const char* | s | Stringa da cercare + + // @syntax find(char c, int from); + // @syntax find(const char* s, int from); + // + // @comm Cerca nella stringa, dalla posizione indicata, l'elemento passato. + // Nel caso

sia maggiore della lunghezza della stringa manda + // un messaggio di errore { CHECKD(from <= len(), "Trying to find past end of string", from); const char* p = strchr(_str + from, c); @@ -248,8 +292,12 @@ int TString::find(char c, int from) const } // Certified 50% -bool TString::match(const char* s) const - +// @mfunc Confronta usando i caratteri jolly +bool TString::match( + const char* s) const // @parm Stringa da confrontare + + // @comm Confronta se la stringa e' parzialmente uguale ad un'altra, cioe' non confrontando + // tutti i caratteri, ma solo quelli non jolly { if (strchr(s, '?') == NULL) return operator ==(s); @@ -282,14 +330,22 @@ int TString::find(const char* s, int from) const // Certified 99% -const TString& TString::left(int count) const +// @mfunc Ritorna l'oggetto TString composto dai

caratteri da sinistra +const TString& TString::left( + int count) const // @parm Indica fino quale carattere restituire la stringa + + // @rdesc Ritorna l'indirizzo della stringa contenente i

caratteri da sinistra { spark.strncpy(_str, count); return spark; } // Certified 99% -const TString& TString::right(int count) const +// @mfunc Ritorna l'oggetto TString composto dai

caratteri da destra +const TString& TString::right( + int count) const // @parm Indica da quale carattere restituire la stringa + + // @rdesc Ritorna l'indirizzo della stringa contenente i

caratteri da destra { int from = len()-count; if (from < 0) from = 0; @@ -299,7 +355,13 @@ const TString& TString::right(int count) const // Certified 100% -const TString& TString::mid(int from, int count) const +// @mfunc Ritorna l'oggetto TString composto dai

caratteri a partire +// da

+const TString& TString::mid( + int from, // @parm Posizione dalla quale partire per l'estrazione + int count) const // @parm Numero di caratteri da estrarre + + // @rdesc Ritorna l'indirizzo della stringa contenente i

cartteri da

{ const int l = len(); @@ -320,7 +382,12 @@ const TString& TString::mid(int from, int count) const // Certified 100% -const TString& TString::sub(int from, int to) const +// @mfunc Ritorna la stringa da

a

(escluso) +const TString& TString::sub( + int from, // @parm Posizione dalla quale estrarre la stringa + int to) const // @parm Posizione fin alla quale estrarre la stringa + + // @rdesc Ritorna l'indirizzo della stringa da i

a

{ const int count = to-from; return mid(from, count); @@ -334,7 +401,17 @@ TString& TString::cut(int n) } -TString& TString::ltrim(int count) +// @mfunc Elimina gli spazi da sinistra o i primi n caratteri (da sinistra). +TString& TString::ltrim( + int count) // @parm Indica il numero di caratteri da eliminare. + // Se uguale a 0 elimina tutti gli spazi da sinistra + + // @comm Controlla se

e' 0. Se non lo Š ritorna l'indirizzo della + // stringa a partire dal

-esimo carattere; altrimenti controlla + // se i primi caratteri sono spazi e li elimina fino a che non trova + // un carattere diverso da ' ' + // + // @xref { const char* s; @@ -349,7 +426,16 @@ TString& TString::ltrim(int count) return *this; } -TString& TString::rtrim(int count) +// @mfunc Elimina gli spazi da destra o i primi n caratteri (da destra). +TString& TString::rtrim( + int count) // @parm Indica il numero di caratteri da eliminare. + // Se uguale a 0 elimina tutti gli spazi da destra + + // @comm Controlla se

e' 0. Se non lo Š pone il fine stringa alla + // posizione

; altrimenti controlla se gli ultimi caratteri + // sono spazi e li elimina fino a che non trova un carattere diverso da ' ' + // + // @xref { if (count > 0) { @@ -391,7 +477,16 @@ TString& TString::trim() } // Certified 50% -int TString::compare(const char* s, int max, bool ignorecase) const +// @mfunc Compara due stringhe (o i primi

caratteri) +// +// @rdesc Ritrna i seguenti valori: +// +// @flag 0 | Se le stringhe sono uguali +// @flag 0 | Se le stringhe sono diverse +int TString::compare( + const char* s, // @parm Stringa da comparare + int max, // @parm Numero di caratteri da conforntare (default tutta la stringa) + bool ignorecase) const // @parm Ignorare la differenza maiuscolo/minuscolo (default FALSE) { int res; if (ignorecase) @@ -414,7 +509,18 @@ int TString::compare(const char* s, int max, bool ignorecase) const } // Certified 100% -TString& TString::fill(char c, int n) +// @mfunc Riempe la stringa con n caratteri c +TString& TString::fill( + char c, // @parm Caratteri con cui riempire la stringa + int n) // @parm Numero di caratteri da inserire nella stringa + // (default per tutta la lungehzza) + + // @comm Se il paramatro

e' maggiore della dimensione della stringa, la + // stessa viene ridimensionata (chaimata alla ). + // Nel caso non venga passato il parametro

la stringa viene + // riempita col carattere

per tutta la lunghezza. + // + // @rdesc Ritorna l'indirizzo dell stringa { if (n < 0) n = size(); else if (n > size()) resize(n, FALSE); @@ -424,7 +530,15 @@ TString& TString::fill(char c, int n) } // Certified 100% -TString& TString::right_just(int n, char c) +// @mfunc Giustifica l'oggetto stringa a destra +TString& TString::right_just( + int n, // @parm Numero di colonne alla quali allineare (defualt larghezza della stringa) + char c) // @parm Carattere di riempimento (default ' ') + + // @comm Nel caso venga passato un carattere in

, questo viene inserito + // nel resto della stringa (a sinistra della stringa stessa) + // + // @xref { if (n < 0) n = size(); trim(); @@ -436,7 +550,15 @@ TString& TString::right_just(int n, char c) } // Certified 100% -TString& TString::center_just(int n, char c) +// @mfunc Centra l'oggetto stringa +TString& TString::center_just( + int n, // @parm Numero di colonne alla quali allineare (defualt larghezza della stringa) + char c) // @parm Carattere di riempimento (default ' ') + + // @comm Nel caso venga passato un carattere in

, questo viene inserito + // nel resto della stringa (a destra e a sinistra della stringa stessa) + // + // @xref { if (n < 0) n = size(); trim(); @@ -449,7 +571,15 @@ TString& TString::center_just(int n, char c) } // Certified 100% -TString& TString::left_just(int n, char c) +// @mfunc Giustifica l'oggetto stringa a sinistra +TString& TString::left_just( + int n, // @parm Numero di colonne alla quali allineare (defualt larghezza della stringa) + char c) // @parm Carattere di riempimento (default ' ') + + // @comm Nel caso venga passato un carattere in

, questo viene inserito + // nel resto della stringa (a destra della stringa stessa) + // + // @xref { if (n < 0) n = size(); trim(); @@ -460,7 +590,10 @@ TString& TString::left_just(int n, char c) return *this; } -TString& TString::picture(const char* pic, const char* s) +// @mfunc Formatta una stringa usando il formato dato da

+TString& TString::picture( + const char* pic, // @parm Formato dell stringa + const char* s) // @parm Stringa da formattare { if (pic == NULL || *pic == '\0') return set(s); @@ -481,7 +614,12 @@ TString& TString::picture(const char* pic, const char* s) } // Certified 90% (spark size limited) -TString& TString::format(const char* fmt, ...) +// @mfunc Manda un output formattato alla stringa oggetto +TString& TString::format( + const char* fmt, ...) // @parm Stringa da formattare + + // @comm Funziona come la funzione "sprintf" standard del C e ritorna la + // stringa formattata con i parametri passati. { va_list pars; va_start(pars, fmt); @@ -510,7 +648,14 @@ TString& TString::lower() } // Certified 50% -TString& TString::add_plural(long num, const char* name) +// @mfunc Permette di ttrovare il plurale di una stringa +TString& TString::add_plural( + long num, // @parm Numero di elementi per sapere la desineneza + const char* name) // @parm Stringa da modificare + + // @comm A seconda del numero passato in

permette di stabilire la + // corretta sintassi della stringa

da scrivere nei messaggi + // dati all'utente. Nel caso

sia 0 allora ritorna "nessuno". { const TFixed_string n(name); const char last = n[n.len()-1]; @@ -534,7 +679,16 @@ TString& TString::add_plural(long num, const char* name) } // Certified 90% -TString& TString::overwrite(const char* s, int pos) +// @mfunc Sovrascrive la stringa

dalla posizione

+TString& TString::overwrite( + const char* s, // @parm Stringa da inserire + int pos) // @parm Posizione dalla quale iniziare a sovrascrivere + + // @comm Sovrascrive dalla posizione

fino alla lunghezza di

l'oggetto + // stringa. Nel caso la dimensione sia maggiore l'oggetto viene riallocato + // dinamicamente + // + // @xref { const int l = len(); if (pos < 0) pos = l; @@ -551,7 +705,16 @@ TString& TString::overwrite(const char* s, int pos) // Certified 90% -TString& TString::insert(const char* s, int pos) +// @mfunc Inserisce la stringa s dalla posizione pos +TString& TString::insert( + const char* s, // @parm Stringa da inserire + int pos) // @parm Posizione dalla quale iniziare a inserire + + // @comm Inserisce dalla posizione

la stringa

nell'oggetto + // stringa. Nel caso la dimensione sia maggiore l'oggetto viene riallocato + // dinamicamente + // + // @xref { if (s && *s) { @@ -616,8 +779,13 @@ void TFixed_string::strncpy(const char* s, int n) } // Certified 99% -// More efficient than TString::format, it does not use spark -TString& TFixed_string::format(const char* fmt, ...) +// @mfunc Manda un output formattato alla stringa oggetto +TString& TFixed_string::format( + const char* fmt, ...)// @parm Formato della stringa + + // @comm Funziona come la funzione "sprintf" standard del C e ritorna la + // stringa formattata con i parametri passati. + // E' piu' efficiente di poiche' non usa spark { va_list pars; va_start(pars, fmt); @@ -688,12 +856,22 @@ TFilename& TFilename::add(const char* n) return *this; } +// @mfunc Controlla il formato del nome del file +// +// @rdesc Ritorna i seguenti valori +// +// @flag TRUE | Se il nome del file e' sintatticamente corretto +// @flag FALSE | Se il nome del file non e' sintatticamente corretto bool TFilename::ok() const + +// @comm Controlla tutti i casi per cui un nome di file puo' non essere valido. +// Nel caso si lavori in Windows controlla anche che il nome del +// disco sia corretto. { const int l = len(); - int len = 0; // lunghezza ultima sottostringa - bool ext = FALSE; // trovata estensione + int len = 0; // lunghezza ultima sottostringa + bool ext = FALSE; // trovata estensione for (int c = 0; c < l; c++) { @@ -781,7 +959,12 @@ const TFilename& TFilename::tempdir() } // Certified 50% -const TFilename& TFilename::temp(const char* prefix) +// @mfunc Genera il nome di un file temporaneo +const TFilename& TFilename::temp( + const char* prefix) // @parm Eventuale prefisso da assegnare al file temporaneo + + // @comm Nel generare il nome del file controlla se esistone dei caratteri jolly + // e li elimina. { tempdir(); @@ -876,7 +1059,19 @@ const char* TToken_string::get() } // Certified 50% -const char* TToken_string::get(int n) +// @mfunc Ritorna un Token +// +// @rdesc Ritorne la stringa identificata dal Token passato come parametro

+const char* TToken_string::get( + int n) // @parm Token da ritornare (-1 = prossimo, -2 = ultimo, n = n-simo) + + // @syntax const char* get(int n); + // @syntax const char* get(); + // + // @comm Se non viene passato il parametro

ritorna il prossimo Token + // (come se

== -1) + // + // @xref { if (n < 0) { @@ -919,7 +1114,14 @@ const char* TToken_string::get(int n) // Certified 99% -char TToken_string::get_char(int n) +// @mfunc Ritorna un carattere +// +// @rdesc Ritorna il primo carattere del Token richiesto +char TToken_string::get_char( + int n) // @parm Token da ritornare + + // @comm Chiama la con tutti i relativi significati per + // il parametro

{ const char* const car = get(n); return car ? *car : '\0'; @@ -1000,9 +1202,23 @@ int TToken_string::items() const return t; } -// Adds an item to the token string // Certified 99% -void TToken_string::add(const char* s, int pos) +// @mfunc Aggiunge un elemento alla token string +void TToken_string::add( + const char* s, // @parm Stringa da aggiungere + int pos) // @parm Posizione nella quale aggiungere l'elemento + // (default aggiunge come ultimo elemento) + // @parm char | c | Caratter da aggiungere + // @parm long | n | Long da aggiungere + // @parm int | n | Intero da aggiungere + + // @syntax void add(const char* s, int n = -1); + // @syntax void add(char c, int pos = -1); + // @syntax void add(long n, int pos = -1); + // @syntax void add(int n, int pos = -1); + // + // @comm Permette, a seconda del parametro passato, di aggiungere alla Token + // string un nuovo elemnto gi… completo del carattere di separazione { if (s == NULL || *s == '\0') s = " "; if (pos < 0) @@ -1121,7 +1337,13 @@ int TString_array::add(const TToken_string& s, int n) return n; } -int TString_array::find(const char* s, int from) const +// @mfunc Cerca una stringa nell'array +// +// @rdesc Ritorna la posizione nell'array in cui si trova la stringa (-1 se non +// e' stata trovata) +int TString_array::find( + const char* s, // @parm Stringa da cercare + int from) const // @parm Posizione dalla quale cercare la stringa { int found = -1; for (int i = from; i < items(); i++) diff --git a/include/strings.h b/include/strings.h index 399be1de3..690e1b336 100755 --- a/include/strings.h +++ b/include/strings.h @@ -9,152 +9,276 @@ #include #endif -// @C -// Classe TString : public TObject -// @END +// @doc EXTERNAL +// @class Classe per la definizione della stringhe +// +// @base public | TObject class TString : public TObject { -protected: - // @DPROT - char* _str; // Puntatore alla stringa - int _size; // Lunghezza - // @END + // @access Protected Member +protected: + // @cmember Puntatore alla stringa + char* _str; + // @cmember Lunghezza della stringa + int _size; - // @FPROT - int make_room(int size); // Cerca spazio per altri size caratteri - TString& set(const char*); // Inizializza con la stringa puntata da char* di lunghezza size + // @cmember Espande la stringa per altri caratteri + int make_room(int size); + // @cmember Inizializza con la stringa puntata da char* di lunghezza size + TString& set(const char*); - TString(char* str, int size) : _str(str), _size(size) {} + // @cmember Costruttore per consentire la derivazione delle TFixed_string + TString(char* str, int size) : _str(str), _size(size) + {} + // @access Public member public: - // @FPUB - virtual void resize(int size, bool cpy); // Ri/alloca la stringa + // @cmember Rialloca la stringa + virtual void resize(int size, bool cpy); + // @cmember Costruttore TString(); - TString(int size); // Default constructor for a string of given size - TString(const char* s); // Costruttore a partire da una stringa s - TString(const TString& s); // Costruttore da un oggetto TString s - virtual ~TString(); // Deallocates the string + // @cmember Costruttore di default per una stringa data + TString(int size); + // @cmember Costruttore a partire da una stringa s + TString(const char* s); + // @cmember Costruttore da un oggetto TString s + TString(const TString& s); + // @cmember Distruttore + virtual ~TString(); - virtual const char* class_name() const; // Ritorna il nome della classe - virtual word class_id() const; // Ritorna l'identificatore della classe - virtual bool ok() const { return _str != NULL; } + // @cmember Ritorna il nome della classe + virtual const char* class_name() const; + // @cmember Ritorna l'identificatore della classe + virtual word class_id() const; + // @cmember Controlla se si tratta di una stringa valida (diversa da NULL) + virtual bool ok() const + { return _str != NULL; } + // @cmember Duplica una stringa virtual TObject* dup() const; + // @cmember Stampa una stringa virtual void print_on(ostream& out) const; + // @cmember Legge una stringa virtual void read_from(istream& in); - virtual word hash() const; // Return hash value + // @cmember Ritorna il valore hash della stringa + virtual word hash() const; - operator const char*() const { return (const char*)_str; } // *(TString) -> _str - char& operator[](int i) // TString[i] -> _str[i] + // @cmember const char * | operator const char*() | | Trasforna una stringa + // in puntatore a carattere + operator const char*() const + { return (const char*)_str; } + // @cmember Ritorna un riferimento al carattere i-esimo della stringa + char& operator[](int i) { CHECKD(i >= 0 && i <= _size, "Bad string subscript: ", i); return _str[i]; - } - char operator[](int i) const // TString[i] -> _str[i] + } + // @cmember Ritorna il carattere i-esimo della stringa + char operator[](int i) const { CHECKD(i >= 0 && i <= _size, "Bad string subscript: ", i); return _str[i]; } - int size() const { return _size; } + // @cmember Ritorna la dimensione allocata della stringa + int size() const + { return _size; } + // @cmember Ritorna la lunghezza della stringa (numero di caratteri) int len() const { return strlen(_str); } - bool empty() const { return *_str == '\0'; } - bool not_empty() const { return *_str != '\0'; } - bool blank() const; // TRUE se e' vuota o contiene solo whitespace + // @cmember Controlla se la stringa e' vuota (TRUE se non contiene caratteri) + bool empty() const + { return *_str == '\0'; } + // @cmember Controlla se la stringa non e' vuota (TRUE se contiene caratteri) + bool not_empty() const + { return *_str != '\0'; } + // @cmember Controlla se la stringa e' vuota o contiene solo whitespace (TRUE se vuota) + bool blank() const; - int find(char, int from = 0) const; // Ritorna la posizione del carattere char nell'oggetto TString - int find(const char* s, int from = 0) const; // Ritorna la posizione della stringa s nell'oggetto TString + // @cmember Ritorna la posizione del carattere char nell'oggetto TString + int find(char, int from = 0) const; + // @cmember Ritorna la posizione della stringa s nell'oggetto TString + int find(const char* s, int from = 0) const; - const TString& left(int count) const; // Ritorna l'oggetto TString composto dai count caratteri da sinistra - const TString& mid(int from, int count = -1) const; // Ritorna l'oggetto TString composto dai count caratteri a partire da from - const TString& sub(int from, int to = -1) const; // Ritorna la stringa da FROM a TO (escluso) - const TString& right(int count) const; // Ritorna l'oggetto TString composto dai count caratteri da destra + // @cmember Ritorna l'oggetto TString composto dai count caratteri da sinistra + const TString& left(int count) const; + // @cmember Ritorna l'oggetto TString composto dai count caratteri a partire da from + const TString& mid(int from, int count = -1) const; + // @cmember Ritorna la stringa da from a to (escluso) + const TString& sub(int from, int to = -1) const; + // @cmember Ritorna l'oggetto TString composto dai count caratteri da destra + const TString& right(int count) const; - TString& fill(char c, int n = -1); // Riempie con n caratteri c - TString& spaces(int n = -1) { return fill(' ', n); } - TString& overwrite(const char* s, int pos = 0); // Sovrascrive la stringa s dalla posizione pos - TString& insert(const char* s, int pos = 0); // Inserisce la stringa s dalla posizione pos + // @cmember Riempe la stringa con n caratteri c + TString& fill(char c, int n = -1); + // @cmember Riempe la stringa con n caratteri spazio (chiama ) + TString& spaces(int n = -1) + { return fill(' ', n); } + // @cmember Sovrascrive la stringa s dalla posizione pos + TString& overwrite(const char* s, int pos = 0); + // @cmember Inserisce la stringa s dalla posizione pos + TString& insert(const char* s, int pos = 0); - TString& strip(const char* k); // Elimina tutti i caratteri contenuti in k - TString& strip_spaces(); // Elimina tutti gli spazi non contenuti tra apici singoli o doppi - TString& ltrim(int n = 0); // Elimina gli spazi da sinistra se n=0 altrimenti elimina i primi n caratteri (da sinistra). - TString& rtrim(int n = 0); // Elimina gli spazi da destra se n=0 altrimenti elimina i primi n caratteri (da destra). - TString& trim(); // ltrim e rtrim + // @cmember Elimina tutti i caratteri contenuti in k + TString& strip(const char* k); + // @cmember Elimina tutti gli spazi non contenuti tra apici singoli o doppi + TString& strip_spaces(); + // @cmember Elimina gli spazi da sinistra o i primi n caratteri (da sinistra). + TString& ltrim(int n = 0); + // @cmember Elimina gli spazi da destra o i primi n caratteri (da destra). + TString& rtrim(int n = 0); + // @cmember Composizione di e per eliminare + // gli spazi iniziali e finali + TString& trim(); - TString& right_just(int n = -1, char c = ' '); // Giustifica a destra - TString& center_just(int n = -1, char c = ' '); // Centra - TString& left_just(int n = -1, char c = ' '); // Giustifica a sinistra + // @cmember Giustifica l'oggetto stringa a destra + TString& right_just(int n = -1, char c = ' '); + // @cmember Centra l'oggetto stringa + TString& center_just(int n = -1, char c = ' '); + // @cmember Giustifica l'oggetto stringa a sinistra + TString& left_just(int n = -1, char c = ' '); + // @cmember Formatta una stringa usando il formato dato da pic TString& picture(const char* pic, const char* s); + #ifndef __WATCOMC__ virtual #endif + // @cmember Manda un output formattato alla stringa oggetto TString& format(const char* fmt, ...); - TString& cut(int n); // Inserisce un '\0' alla posizione n-esima. - TString& upper(); // Mette la stringa in maiuscolo - TString& lower(); // Mette la stringa in minuscolo - TString& add_plural(long num, const char * name); // aggiunge il plurale di name + // @cmember Tronca la stringa alla posizione n-esima. + TString& cut(int n); - const TString& operator =(const TString& s) { return set(s._str); } - const TString& operator =(const char* s) { return set(s); } + // @cmember Converte la stringa in maiuscolo + TString& upper(); + // @cmember Converte la stringa in minuscolo + TString& lower(); + // @cmember Permette di ttrovare il plurale di una stringa + TString& add_plural(long num, const char * name); + // @cmember Assegna la stringa passata con indirizzo + const TString& operator =(const TString& s) + { return set(s._str); } + // @cmember Assegna la stringa passata + const TString& operator =(const char* s) + { return set(s); } + + // @cmember Concatena una stringa all'oggetto stringa TString& operator <<(const char*); + // @cmember Concatena un carattere all'oggetto stringa TString& operator <<(char); + // @cmember Concatena un intero all'oggetto stringa TString& operator <<(int); + // @cmember Concatena un long all'oggetto stringa TString& operator <<(long); + // @cmember Concatena un double all'oggetto stringa TString& operator <<(double); + // @cmember Concatena un oggetto all'oggetto stringa TString& operator <<(const TObject& obj); - TString& operator <<(const TString& str); // For efficiency only + // @cmember Concatena una stringa all'oggetto stringa (usato per aumentare l'efficienza) + TString& operator <<(const TString& str); - bool operator ==(const char* s) const { return strcmp(_str, s) == 0; } - bool operator ==(char* s) const { return strcmp(_str, s) == 0; } - bool operator ==(const TString& s) const { return strcmp(_str, s._str) == 0; } - bool operator !=(const char* s) const { return strcmp(_str, s) != 0; } - bool operator !=(char* s) const { return strcmp(_str, s) != 0; } - bool operator !=(const TString& s) const { return strcmp(_str, s._str) != 0; } - bool operator <(const char* s) const { return strcmp(_str, s) < 0; } - bool operator >(const char* s) const { return strcmp(_str, s) > 0; } - bool operator >=(const char* s) const { return strcmp(_str, s) >= 0; } - bool operator <=(const char* s) const { return strcmp(_str, s) <= 0; } - bool match(const char* s) const; + // @cmember Controlla se due stringhe sono uguali + bool operator ==(const char* s) const + { return strcmp(_str, s) == 0; } + // @cmember Controlla se due stringhe sono uguali + bool operator ==(char* s) const + { return strcmp(_str, s) == 0; } + // @cmember Controlla se due oggetti stringa sono uguali + bool operator ==(const TString& s) const + { return strcmp(_str, s._str) == 0; } + // @cmember Controlla se due stringhe sono diversi + bool operator !=(const char* s) const + { return strcmp(_str, s) != 0; } + // @cmember Controlla se due stringhe sono diversi + bool operator !=(char* s) const + { return strcmp(_str, s) != 0; } + // @cmember Controlla se due oggetti stringa sono diverse + bool operator !=(const TString& s) const + { return strcmp(_str, s._str) != 0; } + // @cmember Controlla se una stringa e piu' lunga di un'altra + bool operator <(const char* s) const + { return strcmp(_str, s) < 0; } + // @cmember Controlla se una stringa e piu' corta di un'altra + bool operator >(const char* s) const + { return strcmp(_str, s) > 0; } + // @cmember Controlla se una stringa e piu' lunga o uguale ad un'altra + bool operator >=(const char* s) const + { return strcmp(_str, s) >= 0; } + // @cmember Controlla se una stringa e piu' corta o uguale ad un'altra + bool operator <=(const char* s) const + { return strcmp(_str, s) <= 0; } + // @cmember Confronta usando i caratteri jolly + bool match(const char* s) const; + // @cmember Compara due stringhe (o i primi max caratteri) int compare(const char* s, int max = -1, bool ignorecase = FALSE) const; }; -// @C -// Classe TFixed_string : public TString -// @END - +// @class TFixed_string | Classe per la definizione di stringhe di lunghezza +// fissa e non rilocabili dinamicamente +// +// @base public | TString class TFixed_string : public TString { -protected: - virtual void resize(int size, bool cpy); // Causa un errore fatale! + // @access Protected Member +protected: + // @cmember Causa un erroe fatale + virtual void resize(int size, bool cpy); + + // @access Public Member public: + // @cmember Costruttore TFixed_string(const char* str, int size = -1); + // @cmember Distruttore virtual ~TFixed_string(); #ifndef __WATCOMC__ virtual #endif + // @cmember Manda un output formattato alla stringa oggetto TString& format(const char* fmt, ...); - const TString& operator =(const TString& s) { return set((const char*)s); } - const TString& operator=(const char* str) { return set(str); } + // @cmember Assegna la stringa passata con indirizzo + const TString& operator =(const TString& s) + { return set((const char*)s); } + // @cmember Assegna la stringa passata + const TString& operator =(const char* str) + { return set(str); } + // @cmember Copia n caratteri nella stringa oggetto void strncpy(const char* s, int n); }; +// @class TString16 | Definisce le stringhe di 16 caratteri +// +// @base public | TFixed_string class TString16 : public TFixed_string { + // @access Private member + + // @cmember Stringa di 16 caratteri char _str16[17]; + // @access Public Member public: - TString16(const char* s = "") : TFixed_string(_str16, 17) { set(s); } - TString16(const TString& s) : TFixed_string(_str16, 17) { set(s); } - const TString& operator =(const TString& s) { return set((const char*)s); } - const TString& operator =(const char* s) { return set(s); } + // @cmember Costruttore + TString16(const char* s = "") : TFixed_string(_str16, 17) + { set(s); } + // @cmember Costruttore + TString16(const TString& s) : TFixed_string(_str16, 17) + { set(s); } + // @cmember Assegna una stringa + const TString& operator =(const TString& s) + { return set((const char*)s); } + // @cmember Assegna una stringa + const TString& operator =(const char* s) + { return set(s); } + + // @comm Sono definite anche le classi e per le + // stringhe rispettivamente di 80 e 256 caratteri. I class member sono + // gli stessi, la differenza e' solo nel numero di caratteri della stringa. }; class TString80 : public TFixed_string @@ -179,121 +303,196 @@ public: const TString& operator =(const TString& s) { return set((const char*)s); } }; - - -// @C -// Classe TFilename : public TString80 (256 su Windows'95) -// @END - +// @class TFilename | Classe per la gestione dei nome dei file +// +// @base public | TString80 (TString256 per Windows '95) class TFilename : public TString80 { + + // @access Public Member public: - // @FPUB + // @cmember Costruttore + TFilename(const char* n = "") : TString80(n) + {} + // @cmember Costruttore + TFilename(const TString& n) : TString80((const char*)n) + {} + // @cmember Costruttore + TFilename(const TFilename& n) : TString80((const char*)n) + {} - TFilename(const char* n = "") : TString80(n) {} - TFilename(const TString& n) : TString80((const char*)n) {} - TFilename(const TFilename& n) : TString80((const char*)n) {} - - // assegnazione tra TFile e stringa - const TString& operator =(const char* s) { return set(s); } - const TString& operator =(const TString& s) { return set((const char*)s); } + // @cmember Assegnazione tra TFile e stringa + const TString& operator =(const char* s) + { return set(s); } + // @cmember Assegnazione tra TFile ed indirizzo della stringa + const TString& operator =(const TString& s) + { return set((const char*)s); } - virtual bool ok() const; // Controlla il formato del nome del file + // @cmember Controlla il formato del nome del file + virtual bool ok() const; - const char* ext() const; // Ritorna l'estensione - void ext(const char*); // Imposta come estensione la stringa puntata da char* + // @cmember Ritorna l'estensione del file + const char* ext() const; + // @cmember Imposta come estensione la stringa puntata da char* + void ext(const char*); + // @cmember Concatena un nome di file ad una directory TFilename& add(const char* n); - const char* name() const; // Ritorna il nome del file - const char* path() const; // Ritorna il nome del direttorio - const TFilename& temp(const char* prefix = NULL); // Genera il nome di un file temporaneo - const TFilename& tempdir(); // Genera il nome della directory temporanea + // @cmember Ritorna il nome del file + const char* name() const; + // @cmember Ritorna il nome del direttorio + const char* path() const; + // @cmember Genera il nome di un file temporaneo + const TFilename& temp(const char* prefix = NULL); + // @cmember Genera il nome della directory temporanea + const TFilename& tempdir(); }; -// @C -// Classe TToken_string : public TString -// @END - +// @class TToken_string | Contiene una stringa formata da piu' stringhe +// separate da un carattere (di solito il pipe) +// +// @base public | TString class TToken_string : public TString { - // @DPRIV - char _separator; // Carattere separatore - int _last; // Puntatore all'ultimo + // @access Private Member + + // @cmember Carattere separatore + char _separator; + // @cmember Puntatore all'ultimo + int _last; + + // @access Protected Member protected: - // @FPROT - - virtual TObject* dup() const; // Crea un duplicato della token string + // @cmember Crea un duplicato della token string + virtual TObject* dup() const; + // @cmember Inserisce l'n-esima stringa bool set_item(const char* v, int n); + // @access Public Member public: - // @FPUB + // @cmember Costruttore TToken_string(const char* = "", char separator = '|'); + // @cmember Costruttore TToken_string(int n, char separator = '|'); + // @cmember Costruttore TToken_string(const TToken_string& s); - void separator(char s) { _separator = s; } // Setta il separatore a s + // @cmember Setta il carattere separatore a s + void separator(char s) + { _separator = s; } - void restart() { _last = empty() ? -1 : 0; } // Rimette all'inizio il puntatore - const TString& operator =(const char* s) { set(s);restart();return *this; } - const TString& operator =(const TString& s) { set(s);restart();return *this; } + // @cmember Rimette all'inizio il puntatore + void restart() + { _last = empty() ? -1 : 0; } + // @cmember Assegna una stringa + const TString& operator =(const char* s) + { set(s);restart();return *this; } + // @cmember Assegna una stringa + const TString& operator =(const TString& s) + { set(s);restart();return *this; } - void add(const char* s, int n = -1); // Aggiunge una stringa - void add(char c, int pos = -1); // Aggiunge un char - void add(long n, int pos = -1); // Aggiunge un intero - void add(int n, int pos = -1); // Aggiunge un intero - void destroy(int pos); // Toglie la stringa pos - const char* get(); // Ritorna il prossimo token - const char* get(int n); // Ritorna un token (-1 = prossimo; -2 = ultimo; n = ennesimo) - char get_char(int n = -1); // Ritorna un carattere - int get_int(int n = -1); // Ritorna un intero - long get_long(int n = -1); // Ritorna un intero esteso - int get_pos(const char* s); // Ritorna la posizione dell'item s - int items() const; // Ritorna il numero di token presenti - bool empty_items() const; // Controlla se tutti i token sono nulli + // @cmember Aggiunge una stringa + void add(const char* s, int n = -1); + // @cmember Aggiunge un carattere + void add(char c, int pos = -1); + // @cmember Aggiunge un long + void add(long n, int pos = -1); + // @cmember Aggiunge un intero + void add(int n, int pos = -1); + // @cmember Toglie la stringa di posizione pos + void destroy(int pos); + // @cmember Ritorna il prossimo token + const char* get(); + // @cmember Ritorna un token + const char* get(int n); + // @cmember Ritorna un carattere (chiama ) + char get_char(int n = -1); + // @cmember Ritorna un intero (chiama ) + int get_int(int n = -1); + // @cmember Ritorna un intero esteso (chiama ) + long get_long(int n = -1); + // @cmember Ritorna la posizione dell'item s + int get_pos(const char* s); + // @cmember Ritorna il numero di token presenti + int items() const; + // @cmember Controlla se tutti i token sono nulli + bool empty_items() const; }; /////////////////////////////////////////////////////////// -// @DES Paragraph +// DES Paragraph /////////////////////////////////////////////////////////// +// @class TParagraph_string | Classe che serve per spezzare le stringhe in paragrafi +// lunghi al massimo la lunghezza fissata +// +// @base public | TToken_string class TParagraph_string : public TToken_string { - int _width; - bool _fixed; + // @access Private Member + // @cmember Lunghezza massima del paragrafo + int _width; + + // @access Protected Member protected: + // @cmember Spezza la stringa in paragrafi di lunghezza massima fissata void tokenize(); + // @access Public Member public: + // @cmember Costruttore TParagraph_string(const char* s, int width); + // @cmember Assegna una stringa const TString& operator =(const char* s); - const TString& operator =(const TString & s) { return operator=((const char *) s);} - void set_width(int width) { _width = width; } + // @cmember Assegna un oggetto stringa + const TString& operator =(const TString & s) + { return operator=((const char *) s);} + // @cmember Permette di assegnare la lunghezza massima del paragrafo + void set_width(int width) + { _width = width; } }; /////////////////////////////////////////////////////////// -// @DES TString_array +// DES TString_array /////////////////////////////////////////////////////////// +// @class TString_array | Array di stringhe +// +// @base public | TArray class TString_array : public TArray { -public: - TToken_string& row(int n) { return (TToken_string&)operator[](n); } - const TToken_string& row(int n) const { return (TToken_string&)operator[](n); } - TToken_string* rowptr(int n) { return (TToken_string*)objptr(n); } - int add(TToken_string* s, int n = -1) { return TArray::add(s, n); } + // @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 (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 Aggiunge una Token string all'array (chiama ) + int add(TToken_string* s, int n = -1) + { return TArray::add(s, n); } + // @cmember Aggiunge un oggetto stringa all'array (chiama ) int add(const TToken_string& s, int n = -1); + // @cmember Aggiunge una stringa all'array (chiama ) int add(const char* s, int n = -1); + // @cmember Cerca una stringa nell'array int find(const char* s, int from = 0) const; - TString_array(int size = 8) : TArray(size) {} - virtual ~TString_array() {} + // @cmember Costruttore + TString_array(int size = 8) : TArray(size) + {} + // @cmember Distruttore + virtual ~TString_array() + {} }; #endif - - -