502 lines
16 KiB
C++
Executable File
502 lines
16 KiB
C++
Executable File
#ifndef __STRINGS_H
|
|
#define __STRINGS_H
|
|
|
|
#ifndef __STRING_H
|
|
#include <string.h>
|
|
#endif
|
|
|
|
#ifndef __ARRAY_H
|
|
#include <array.h>
|
|
#endif
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class Classe per la definizione della stringhe
|
|
//
|
|
// @base public | TObject
|
|
class TString : public TObject
|
|
{
|
|
// @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 Rialloca la stringa
|
|
virtual void resize(int size, bool cpy);
|
|
|
|
// @cmember Costruttore
|
|
TString();
|
|
// @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();
|
|
|
|
// @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*() | | 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];
|
|
}
|
|
// @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 strlen(_str); }
|
|
// @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 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;
|
|
|
|
// @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 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);
|
|
// @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 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 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, ...);
|
|
|
|
|
|
// @cmember Tronca la stringa alla posizione n-esima.
|
|
TString& cut(int n);
|
|
|
|
// @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);
|
|
// @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 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;
|
|
};
|
|
|
|
// @class TFixed_string | Classe per la definizione di stringhe di lunghezza
|
|
// fissa e non rilocabili dinamicamente
|
|
//
|
|
// @base public | TString
|
|
class TFixed_string : public TString
|
|
{
|
|
|
|
// @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, ...);
|
|
|
|
// @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:
|
|
// @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 <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.
|
|
};
|
|
|
|
class TString80 : public TFixed_string
|
|
{
|
|
char _str80[81];
|
|
|
|
public:
|
|
TString80(const char* s = "") : TFixed_string(_str80, 81) { set(s); }
|
|
TString80(const TString& 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); }
|
|
};
|
|
|
|
class TString256 : public TFixed_string
|
|
{
|
|
char _str256[257];
|
|
|
|
public:
|
|
TString256(const char* s = "") : TFixed_string(_str256, 257) { set(s); }
|
|
TString256(const TString& 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); }
|
|
};
|
|
|
|
// @class TFilename | Classe per la gestione dei nome dei file
|
|
//
|
|
// @base public | TString80
|
|
class TFilename : public TString80
|
|
{
|
|
|
|
// @comm Nel caso di utilizzo di Windows 95 occorre cambiare le classe base in <c TString256>
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @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)
|
|
{}
|
|
|
|
// @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); }
|
|
|
|
// @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 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();
|
|
};
|
|
|
|
// @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
|
|
{
|
|
|
|
// @access Private Member
|
|
|
|
// @cmember Carattere separatore
|
|
char _separator;
|
|
// @cmember Puntatore all'ultimo
|
|
int _last;
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @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:
|
|
// @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 Setta il carattere separatore a s
|
|
void separator(char s)
|
|
{ _separator = s; }
|
|
|
|
// @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 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 <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);
|
|
// @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
|
|
///////////////////////////////////////////////////////////
|
|
|
|
// @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
|
|
{
|
|
// @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);
|
|
// @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
|
|
///////////////////////////////////////////////////////////
|
|
|
|
// @class TString_array | Array di stringhe
|
|
//
|
|
// @base public | TArray
|
|
class TString_array : public TArray
|
|
{
|
|
|
|
// @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 <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 Costruttore
|
|
TString_array(int size = 8) : TArray(size)
|
|
{}
|
|
// @cmember Distruttore
|
|
virtual ~TString_array()
|
|
{}
|
|
};
|
|
|
|
#endif
|