2a3e35827d
Files correlati : ba1.exe Ricompilazione Demo : [ ] Commento : 0001036: installazione cd patch 180 Installando ex novo ed indicando una società esistente di dati su una cartella diversa viene segnalato l'errore ba1.exe in fase di conversione archivi, richiamando da manutenzione archivi la conversione vengono generati gli errori allegati. Nell'area ftp di Aga, cartella Ilaria allego l'area dati SIDA per il test. git-svn-id: svn://10.65.10.50/trunk@17971 c028cbd2-c16b-5b4b-a496-9718f37d4682
765 lines
27 KiB
C++
Executable File
765 lines
27 KiB
C++
Executable File
#ifndef __STRINGS_H
|
|
#define __STRINGS_H
|
|
|
|
#ifndef _INC_STRING
|
|
#include <string.h>
|
|
#endif
|
|
|
|
#ifndef __ARRAY_H
|
|
#include <array.h>
|
|
#endif
|
|
|
|
#define SAFE_PIPE_CHR '¦'
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class Classe per la definizione della stringhe
|
|
//
|
|
// @base public | TObject
|
|
class TString : public TObject
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
// @access Protected Member
|
|
protected:
|
|
// @cmember Puntatore alla stringa
|
|
char* _str;
|
|
// @cmember Lunghezza della stringa
|
|
int _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*);
|
|
|
|
// @cmember Costruttore per consentire la derivazione delle TFixed_string
|
|
TString(char* str, int size) : _str(str), _size(size)
|
|
{}
|
|
|
|
// @access Public member
|
|
public:
|
|
// @cmember Cambia la dimensione della stringa eventualmente preservandone il contenuto iniziale
|
|
virtual void resize(int size, bool cpy);
|
|
|
|
// @cmember Costruttore
|
|
TString();
|
|
// @cmember Costruttore di default per una stringa data
|
|
TString(int size, char c='\0');
|
|
// @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();
|
|
|
|
// @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);
|
|
// @cmember Ritorna il valore hash della stringa
|
|
virtual word hash() const;
|
|
|
|
// @cmember const char * | operator const char*() | | Trasforma 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];
|
|
}
|
|
// @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];
|
|
}
|
|
|
|
// @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 _str ? strlen(_str) : 0; }
|
|
// @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;
|
|
// @cmember Controlla se la stringa NON e' vuota o contiene solo whitespace (true se vuota)
|
|
bool full() const;
|
|
|
|
|
|
// @cmember Ritorna la posizione della prima occorrenza carattere char nell'oggetto TString
|
|
int find(char, int from = 0) const;
|
|
// @cmember Ritorna la posizione dell'ultima occorrenza carattere char nell'oggetto TString
|
|
int rfind(char) const;
|
|
// @cmember Ritorna la posizione della stringa s nell'oggetto TString
|
|
int find(const char* s, int from = 0) const;
|
|
// @cmember Sostituisce le occorrenze di <p find_char> col carattere <p replace_char>
|
|
int replace(char find_char, char replace_char);
|
|
|
|
// @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;
|
|
// @cmember Ritorna l'oggetto TString dopo la string passata
|
|
const TString& after(char c) const;
|
|
const TString& after(const char* str) const;
|
|
// @cmember Ritorna l'oggetto TString prima della string passata
|
|
const TString& before(char c) const;
|
|
const TString& before(const char* str) const;
|
|
|
|
// @cmember Ritorna un oggetto TString temporaneo composto dai count caratteri da sinistra
|
|
TString sleft(int count) const
|
|
{ return ((TString)left(count)); }
|
|
// @cmember Ritorna un oggetto TString temporaneo composto dai count caratteri a partire da from
|
|
TString smid(int from, int count = -1) const
|
|
{ return ((TString)mid(from, count)); }
|
|
// @cmember Ritorna un oggetto TString temporaneo composto dai caratteri da from a to (escluso)
|
|
TString ssub(int from, int to = -1) const
|
|
{ return ((TString)sub(from, to)); }
|
|
// @cmember Ritorna un oggetto TString temporaneo composto dai count caratteri da destra
|
|
TString sright(int count) const
|
|
{ return ((TString)right(count)); }
|
|
|
|
// @cmember Riempe la stringa con n caratteri c
|
|
TString& fill(char c, int n = -1);
|
|
// @cmember Riempe la stringa con n caratteri spazio (chiama <mf TString::resize>)
|
|
TString& spaces(int n = -1)
|
|
{ return fill(' ', n); }
|
|
// @cmember Sovrascrive la stringa s dalla posizione pos
|
|
TString& overwrite(const char* s, int pos = 0, int len = 0);
|
|
// @cmember Inserisce la stringa s dalla posizione pos
|
|
TString& insert(const char* s, int pos = 0);
|
|
|
|
// @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 tutti gli spazi doppi
|
|
TString& strip_double_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 <mf TString::ltrim> e <mf TString::rtrim> per eliminare
|
|
// gli spazi iniziali e finali
|
|
TString& trim();
|
|
// @cmember Aggiunge spazi a destra fino alla dimensione indicata
|
|
TString& rpad(const int n,const char c=' ');
|
|
// @cmember Aggiunge spazi a sinistra fino alla dimensione indicata
|
|
TString& lpad(const int n,const char c=' ');
|
|
|
|
// @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);
|
|
|
|
// @cmember Copia n caratteri nella stringa oggetto
|
|
int strncpy(const char* s, int n);
|
|
|
|
// @cmember Manda un output formattato alla stringa oggetto
|
|
virtual TString& format(const char* fmt, ...);
|
|
|
|
// @cmember Tronca la stringa alla posizione n-esima.
|
|
TString& cut(int n);
|
|
|
|
// @cmember Ritorna il buffer interno della stringa (usare con attenzione!)
|
|
char* get_buffer(int min_size = -1);
|
|
|
|
// @cmember Converte la stringa in maiuscolo
|
|
TString& upper(int from =0, int to=-1);
|
|
// @cmember Converte la stringa in minuscolo
|
|
TString& lower(int from =0, int to=-1);
|
|
// @cmember Permette di trovare 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 Fa scorrere a sinistra la stringa e restituisce l'ultimo carattere scartato
|
|
char shift(int n=1);
|
|
// @cmember Fa scorrere a destra la stringa e restituisce l'ultimo carattere scartato
|
|
char rshift(int n=1)
|
|
{return shift(-n);}
|
|
// @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);
|
|
// @cmember Concatena una stringa all'oggetto stringa (usato per aumentare l'efficienza)
|
|
TString& operator <<(const TString& str);
|
|
|
|
|
|
// @cmember Controlla se due stringhe sono uguali
|
|
bool operator ==(const char* s) const
|
|
{ return s ? strcmp(_str, s) == 0 : empty();}
|
|
// @cmember Controlla se due stringhe sono uguali
|
|
bool operator ==(char* s) const
|
|
{ return s ? strcmp(_str, s) == 0 : empty();}
|
|
// @cmember Controlla se due stringe sono uguali
|
|
bool operator ==(const TString& s) const
|
|
{ return strcmp(_str, s._str) == 0; }
|
|
// @cmember Controlla se due stringhe sono diverse
|
|
bool operator !=(const char* s) const
|
|
{ return s ? strcmp(_str, s) != 0 : not_empty();}
|
|
// @cmember Controlla se due stringhe sono diverse
|
|
bool operator !=(char* s) const
|
|
{ return s ? strcmp(_str, s) != 0 : not_empty();}
|
|
// @cmember Controlla se due stringhe sono diverse
|
|
bool operator !=(const TString& s) const
|
|
{ return strcmp(_str, s._str) != 0; }
|
|
// @cmember Controlla se una stringa e' minore di un'altra
|
|
bool operator <(const char* s) const
|
|
{ return s ? strcmp(_str, s) < 0 : false;}
|
|
// @cmember Controlla se una stringa e' maggiore di un'altra
|
|
bool operator >(const char* s) const
|
|
{ return s ? strcmp(_str, s) > 0 : not_empty();}
|
|
// @cmember Controlla se una stringa e' maggiore o uguale ad un'altra
|
|
bool operator >=(const char* s) const
|
|
{ return s ? strcmp(_str, s) >= 0 : true;}
|
|
// @cmember Controlla se una stringa e' minore o uguale ad un'altra
|
|
bool operator <=(const char* s) const
|
|
{ return s ? strcmp(_str, s) <= 0 : empty();}
|
|
// @cmember Controlla se una stringa e' minore di un'altra
|
|
bool operator <(const TString & s) const
|
|
{ return strcmp(_str, s._str) < 0; }
|
|
// @cmember Controlla se una stringa e' maggiore di un'altra
|
|
bool operator >(const TString & s) const
|
|
{ return strcmp(_str, s._str) > 0; }
|
|
// @cmember Controlla se una stringa e' maggiore o uguale ad un'altra
|
|
bool operator >=(const TString & s) const
|
|
{ return strcmp(_str, s._str) >= 0; }
|
|
// @cmember Controlla se una stringa e' minore o uguale ad un'altra
|
|
bool operator <=(const TString & s) const
|
|
{ return strcmp(_str, s._str) <= 0; }
|
|
// @cmember Confronta usando le regular expression
|
|
bool match(const char* pat, bool ignorecase = false) const;
|
|
// @cmember Compara due stringhe (o i primi max caratteri)
|
|
int compare(const char* s, int max = -1, bool ignorecase = false) const;
|
|
// @cmember Controlla se la strinvga comincia per s
|
|
bool starts_with(const char* s, bool ignorecase = false) const;
|
|
// @cmember Controlla se la strinvga finisce per s
|
|
bool ends_with(const char* s, bool ignorecase = false) const;
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TFixed_string | Classe per la definizione di stringhe di lunghezza
|
|
// fissa e non rilocabili dinamicamente
|
|
//
|
|
// @base public | TString
|
|
class TFixed_string : public TString
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
|
|
// @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();
|
|
|
|
// @cmember Manda un output formattato alla stringa oggetto
|
|
virtual TString& format(const char* fmt, ...);
|
|
|
|
// @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); }
|
|
};
|
|
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TString4 | Definisce le stringhe di 4 caratteri
|
|
//
|
|
// @base public | TFixed_string
|
|
//
|
|
// @author:(INTERNAL) Augusto
|
|
//
|
|
// @comm Questa classe e' identica alla <c TString16> per quanto riguarda i public member e quindi
|
|
// si rimanda a tale classe per ulteriori spiegazioni.
|
|
class TString4 : public TFixed_string
|
|
{
|
|
char _str4[5];
|
|
|
|
public:
|
|
TString4(const char* s = "") : TFixed_string(_str4, 5) { set(s); }
|
|
TString4(const TString& s) : TFixed_string(_str4, 5) { set(s); }
|
|
TString4(const TString4& s) : TFixed_string(_str4, 5) { set(s); }
|
|
const TString& operator =(const char* s) { return set(s); }
|
|
const TString& operator =(const TString& s) { return set((const char*)s); }
|
|
const TString& operator =(const TString4& s) { return set((const char*)s); }
|
|
};
|
|
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TString8 | Definisce le stringhe di 8 caratteri
|
|
//
|
|
// @base public | TFixed_string
|
|
//
|
|
// @author:(INTERNAL) Augusto
|
|
//
|
|
// @comm Questa classe e' identica alla <c TString16> per quanto riguarda i public member e quindi
|
|
// si rimanda a tale classe per ulteriori spiegazioni.
|
|
class TString8 : public TFixed_string
|
|
{
|
|
char _str8[9];
|
|
|
|
public:
|
|
TString8(const char* s = "") : TFixed_string(_str8, 9) { set(s); }
|
|
TString8(const TString& s) : TFixed_string(_str8, 9) { set(s); }
|
|
TString8(const TString8& s) : TFixed_string(_str8, 9) { set(s); }
|
|
const TString& operator =(const char* s) { return set(s); }
|
|
const TString& operator =(const TString& s) { return set((const char*)s); }
|
|
const TString& operator =(const TString8& s) { return set((const char*)s); }
|
|
};
|
|
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TString16 | Definisce le stringhe di 16 caratteri
|
|
//
|
|
// @base public | TFixed_string
|
|
class TString16 : public TFixed_string
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
// @access:(INTERNAL) Private member
|
|
|
|
// @cmember:(INTERNAL) Stringa di 16 caratteri
|
|
char _str16[17];
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @cmember Duplica una stringa di 16 caratteri
|
|
virtual TObject* dup() const { return new TString16(_str16); }
|
|
|
|
// @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 Costruttore
|
|
TString16(const TString16& s) : TFixed_string(_str16, 17)
|
|
{ set(s); }
|
|
// @cmember Assegna una stringa
|
|
const TString& operator =(const char* s)
|
|
{ return 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 TString16& s)
|
|
{ return set((const char*)s); }
|
|
|
|
// @comm Sono definite anche le classi <c TString80> e <c TString256> 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.
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TString80 | Definisce le stringhe di 80 caratteri
|
|
//
|
|
// @base public | TFixed_string
|
|
//
|
|
// @author:(INTERNAL) Guido
|
|
//
|
|
// @comm Questa classe e' identica alla <c TString16> per quanto riguarda i public member e quindi
|
|
// si rimanda a tale classe per ulteriori spiegazioni.
|
|
class TString80 : public TFixed_string
|
|
{
|
|
char _str80[81];
|
|
|
|
public:
|
|
// @cmember Duplica una stringa di 80 caratteri
|
|
virtual TObject* dup() const { return new TString80(_str80); }
|
|
|
|
TString80(const char* s = "") : TFixed_string(_str80, 81) { set(s); }
|
|
TString80(const TString& s) : TFixed_string(_str80, 81) { set(s); }
|
|
TString80(const TString80& s) : TFixed_string(_str80, 81) { set(s); }
|
|
const TString& operator =(const char* s) { return set(s); }
|
|
const TString& operator =(const TString& s) { return set((const char*)s); }
|
|
const TString& operator =(const TString80& s) { return set((const char*)s); }
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TString256 | Definisce le stringhe di 256 caratteri
|
|
//
|
|
// @base public | TFixed_string
|
|
//
|
|
// @author:(INTERNAL) Guido
|
|
//
|
|
// @comm Questa classe e' identica alla <c TString16> per quanto riguarda i public member e quindi
|
|
// si rimanda a tale classe per ulteriori spiegazioni.
|
|
class TString256 : public TFixed_string
|
|
{
|
|
char _str256[257];
|
|
|
|
public:
|
|
// @cmember Duplica una stringa di 256 caratteri
|
|
virtual TObject* dup() const { return new TString256(_str256); }
|
|
|
|
TString256(const char* s = "") : TFixed_string(_str256, 257) { set(s); }
|
|
TString256(const TString& s) : TFixed_string(_str256, 257) { set(s); }
|
|
TString256(const TString256& s) : TFixed_string(_str256, 257) { set(s); }
|
|
const TString& operator =(const char* s) { return set(s); }
|
|
const TString& operator =(const TString& s) { return set((const char*)s); }
|
|
const TString& operator =(const TString256& s) { return set((const char*)s); }
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TFilename | Classe per la gestione dei nome dei file
|
|
//
|
|
// @base public | TString
|
|
class TFilename : public TString
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
// @access Public Member
|
|
public:
|
|
// @cmember Costruttore
|
|
TFilename(const char* n = "") : TString(260)
|
|
{ set(n); }
|
|
// @cmember Costruttore
|
|
TFilename(const TString& n) : TString(260)
|
|
{ set(n); }
|
|
// @cmember Costruttore
|
|
TFilename(const TFilename& n) : TString(260)
|
|
{ set(n); }
|
|
|
|
// @cmember Assegnazione tra TFilename e stringa
|
|
const TString& operator =(const char* s)
|
|
{ return set(s); }
|
|
// @cmember Assegnazione tra TFilename e TString
|
|
const TString& operator =(const TString& s)
|
|
{ return set((const char*)s); }
|
|
// @cmember Assegnazione tra TFilename e TFilename
|
|
const TString& operator =(const TFilename& s)
|
|
{ return set((const char*)s); }
|
|
|
|
// @cmember Controlla il formato del nome del file
|
|
virtual bool ok() const;
|
|
|
|
// @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);
|
|
|
|
// @cmember Controlla se si tratta di un path assoluto
|
|
bool is_absolute_path() const;
|
|
// @cmember Controlla se si tratta di un path relativo
|
|
bool is_relative_path() const { return !is_absolute_path(); }
|
|
// @cmember Trasforma un path da relativo ad assoluto
|
|
const TFilename& make_absolute_path();
|
|
// @cmember Testa se il file esiste
|
|
bool exist() const;
|
|
// @cmember Cancella il file
|
|
bool fremove() const;
|
|
// @cmember Cerca nel path il nome del file corrente e scrive il path assoluto in path
|
|
bool search_in_path(TFilename& path) const;
|
|
// @cmember Richiede all'utente il nome di un file
|
|
bool input();
|
|
// @cmember Ritorna il nome del file con estensione
|
|
const char* name() const;
|
|
// @cmember Ritorna il nome del file senza estensione
|
|
const TString& name_only() const;
|
|
// @cmember Ritorna il nome della cartella del file
|
|
const char* path() const;
|
|
// @cmember Genera il nome di un file temporaneo
|
|
const TFilename& temp(const char* prefix = NULL, const char* extension = NULL);
|
|
// @cmember Genera il nome della directory temporanea
|
|
const TFilename& tempdir();
|
|
// @cmember Genera il nome della directory corrente
|
|
const TFilename& currdir();
|
|
// @cmember Prepone il nome della dir custom
|
|
bool custom_path(const char* path_list = NULL);
|
|
};
|
|
|
|
// Forward declaration for TToken_string::get(int n, real& r) const
|
|
class real;
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @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
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Carattere separatore
|
|
char _separator;
|
|
// @cmember:(INTERNAL) Puntatore all'ultimo
|
|
int _last;
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @cmember Inserisce l'n-esima stringa
|
|
bool set_item(const char* v, int n);
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @cmember Costruttore
|
|
TToken_string(const char* = "", char separator = '|');
|
|
// @cmember Costruttore
|
|
TToken_string(int n, char separator = '|');
|
|
// @cmember Costruttore
|
|
TToken_string(const TToken_string& s);
|
|
// @cmember Distruttore
|
|
~TToken_string();
|
|
|
|
// @cmember Crea un duplicato della token string
|
|
virtual TObject* dup() const;
|
|
// @cmember Setta il carattere separatore a s
|
|
void separator(char s);
|
|
// @cmember Ritorna il carattere separatore
|
|
char separator() const { return _separator; }
|
|
|
|
// @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; }
|
|
// @cmember Assegna una stringa
|
|
const TToken_string& operator =(const TToken_string& s);
|
|
|
|
// @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 Inserisce una stringa
|
|
void insert_at(const char* s, int n);
|
|
// @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 <mf TToken_string::get>)
|
|
char get_char(int n = -1);
|
|
// @cmember Ritorna un intero (chiama <mf TToken_string::get>)
|
|
int get_int(int n = -1);
|
|
// @cmember Ritorna un intero esteso (chiama <mf TToken_string::get>)
|
|
long get_long(int n = -1);
|
|
|
|
// TToken_string new age: const methods;
|
|
// @cmember Ritorna l'ennesimo token
|
|
bool get(int n, TString& tok) const;
|
|
// @cmember Ritorna l'ennesimo char
|
|
bool get(int n, char& tok) const;
|
|
// @cmember Ritorna l'ennesimo int
|
|
bool get(int n, int& tok) const;
|
|
// @cmember Ritorna l'ennesimo long
|
|
bool get(int n, long& tok) const;
|
|
// @cmember Ritorna l'ennesimo real
|
|
bool get(int n, real& tok) const;
|
|
|
|
// @cmember Ritorna la posizione dell'item s
|
|
int get_pos(const char* s);
|
|
// @cmember Ritorna la posizione dell'item s
|
|
int get_pos(long s);
|
|
// @cmember Ritorna il numero di token presenti
|
|
int items() const;
|
|
// @cmember Controlla se tutti i token sono nulli
|
|
bool empty_items() const;
|
|
};
|
|
|
|
#define FOR_EACH_TOKEN(__tok, __str) \
|
|
for (const char* __str = __tok.get(0); __str; __str = __tok.get())
|
|
#define FOR_EACH_STR_TOKEN(__tok, __str) \
|
|
TString __str;for (int __t=0;__tok.get(__t,__str);__t++)
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Mitica token string che sceglie da sola il separatore
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TAuto_token_string : public TToken_string
|
|
{
|
|
protected:
|
|
TAuto_token_string& create(const char* ts);
|
|
|
|
public:
|
|
TAuto_token_string& operator=(const char* ts) { return create(ts); }
|
|
TAuto_token_string& operator=(const TString& ts) { return create(ts); }
|
|
TAuto_token_string& operator=(const TToken_string& ts) { return create(ts); }
|
|
TAuto_token_string& operator=(const TAuto_token_string& ts) { return create(ts); }
|
|
TAuto_token_string(int sz = 50) : TToken_string(sz) { }
|
|
TAuto_token_string(const char* ts) { create(ts); }
|
|
virtual ~TAuto_token_string() { }
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TParagraph_string
|
|
///////////////////////////////////////////////////////////
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @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
|
|
// @author:(INTERNAL) Guido
|
|
{
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) 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 Distruttore
|
|
virtual ~TParagraph_string() { }
|
|
|
|
// @cmember Assegna una stringa
|
|
const TString& operator =(const char* s);
|
|
// @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
|
|
///////////////////////////////////////////////////////////
|
|
|
|
// @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)
|
|
{ return TArray::add(s, n); }
|
|
// @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 Costruttore
|
|
TString_array(int size = 8) : TArray(size)
|
|
{}
|
|
// @cmember Distruttore
|
|
virtual ~TString_array()
|
|
{}
|
|
};
|
|
|
|
TString& user();
|
|
|
|
TToken_string& get_tmp_string(int len = -1);
|
|
|
|
const TToken_string& empty_string();
|
|
#define EMPTY_STRING empty_string()
|
|
|
|
#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))
|
|
|
|
const char SLASH =
|
|
#if XVT_OS == XVT_OS_WIN32
|
|
'\\';
|
|
#else
|
|
'/';
|
|
#endif
|
|
|
|
#endif
|