#ifndef __RELATION_H #define __RELATION_H #ifndef __ISAM_H #include #endif #ifndef __SORT_H class TSort; #endif // @doc EXTERNAL // @class TRelation | Classe per la definizione delle relazioni esistenti tra i file // // @base public | TObject class TRelation : public TObject // @author:(INTERNAL) Sandro { // @cfriend TRelationdef friend class TRelationdef; // @cfriend TRelation_description friend class TRelation_description; // @cfriend TCursor friend class TCursor; // @access:(INTERNAL) Private Member // @cmember:(INTERNAL) Stato della relazione TToken_string _status; // @cmember:(INTERNAL) Array dei descrittori dei file TArray _files; // @cmember:(INTERNAL) Array di TArray _reldefs; // @cmember:(INTERNAL) Codice dell'ultimo errore occorso int _errors; // @access Protected Member protected: // @cmember Ritorna l'indice di

del numero logico passato int log2ind(int logicnum) const; // @cmember Ritorna l'indice di

del alias del file passato int alias2ind(int alias) const; // @cmember Ritorna l'indice di

del nome del file passato int name2ind(const char* name) const; // @cmember Ritorna la

-esima TRelationdef& reldef(int i) const { return (TRelationdef&)_reldefs[i]; } // @cmember Ritorna il descrittore del file

-esimo TLocalisamfile& file(int i = 0) const { return (TLocalisamfile&)_files[i]; } // @cmember Permette di posizionare l'albero di relazioni tra i file int position_rels(TIsamop op = _isequal, TReclock lockop = _nolock, TDate& atdate = (TDate&)botime, int first = 0); // @access Public Member public: // TObject // @cmember Controlla se si tratta di un oggetto valido virtual bool ok() const { return good(); } // @cmember Permette di stampare l'oggetto su

virtual void print_on(ostream& out) const; public: // @cmember Aggiorna l'albero delle relazioni int update() { return position_rels(_isequal, _nolock);} // @cmember Azzera l'abero delle relazioni void zero(); //@cmember Sposta la relazione sul record successivo del file principale (chiama ) virtual int next(TReclock lockop = _nolock) { return file().next(lockop) == NOERR ? position_rels(_isequal, lockop) : file().status(); } //@cmember Sposta la relazione sul record precedente del file principale (chiama ) virtual int prev(TReclock lockop = _nolock) { return file().prev(lockop) == NOERR ? position_rels(_isequal, lockop) : file().status(); } //@cmember Sposta la relazione sul record successivo del file principale (chiama ) virtual int next(TDate& atdate) { return file().next(atdate) == NOERR ? position_rels(_isequal, _nolock, atdate) : file().status(); } //@cmember Sposta la relazione sul record precedente del file principale (chiama ) virtual int prev(TDate& atdate) { return file().prev(atdate) == NOERR ? position_rels(_isequal, _nolock, atdate) : file().status(); } //@cmember Sposta la relazione sul primo record del file principale (chiama ) virtual int first(TReclock lockop = _nolock) { return file().first(lockop) == NOERR ? position_rels(_isequal, lockop) : file().status(); } //@cmember Sposta la relazione sull'ultimo record del file principale (chiama ) virtual int last(TReclock lockop = _nolock) { return file().last(lockop) == NOERR ? position_rels(_isequal, lockop) : file().status(); } //@cmember Salta

posizione dalla corrente sul file principale (chiama ) virtual int skip(TRecnotype nrec, TReclock lockop = _nolock) { return file().skip(nrec, lockop) == NOERR ? position_rels(_isequal, lockop) : file().status(); } //@cmember Legge il record (chiama ) virtual int read(TIsamop op = _isgteq, TReclock lockop = _nolock, TDate& atdate = (TDate&)botime) { return file().read(op, lockop, atdate) == NOERR ? position_rels(_isequal, lockop, atdate) : file().status();} // @cmember Ritorna il descrittore del file TLocalisamfile& lfile(int logicnum = 0) const; // @cmember Ritorna il descrittore del file TLocalisamfile& lfile(const char* name) const; // @cmember Ritorna il descrittore del file (chiama ) TLocalisamfile& operator[] (int logicnum) const { return lfile(logicnum); } // @cmember Abilita/disabilita la scrittura dei record collegati sul file void write_enable(int logicnum = 0, const bool on = TRUE) ; // @cmember Abilita/disabilita la scrittura sul file void write_enable(const char* name, const bool on = TRUE) ; // @cmember Disabilita la scrittura sul file (chiama ) void write_disable(int logicnum = 0) { write_enable(logicnum, FALSE); } // @cmember Disabilita la scrittura sul file (chiama ) void write_disable(const char* name) { write_enable(name, FALSE); } // @cmember Ritorna il record corrente del file

// (chiama ) TRectype& curr(int logicnum = 0) const { return lfile(logicnum).curr(); } // @cmember Posiziona il numero logico sul record successivo bool next_match(int logicnum, const char* fieldlist = NULL, int nkey = 0); // @cmember Aggiunge una nuovo file alla relazione partendo dal descrittore del file bool add(TLocalisamfile* f, const char* relexprs, int key, int linkto, int alias, bool allow_lock); // @cmember Aggiunge una nuovo file alla relazione partendo dal numero logico del file bool add(int logicnum, const char* relexprs, int key = 1, int linkto = 0, int alias = 0, bool allow_lock = FALSE); // @cmember Aggiunge una nuovo file alla relazione partendo dal nome della tabella bool add(const char* tabname, const char* relexprs, int key = 1, int linkto = 0, int alias = 0, bool allow_lock = FALSE); // @cmember Sostituisce nella relazione un file void replace(TLocalisamfile* f, int index = 0); // @cmember Aggiunge il record corrente virtual int write (bool force = TRUE, TDate& atdate = (TDate&)botime); // @cmember Riscrive il record corrente virtual int rewrite (bool force = TRUE, TDate& atdate = (TDate&)botime); // @cmember Elimina il record corrente virtual int remove (TDate& atdate = (TDate&)botime); // @cmember Controlla se e' stata raggiunta la fine del file // (se

= 0 dell'intera relazione, altrimenti del file indicato ) bool eof( int logicnum = 0) const { return lfile(logicnum).eof(); } // @cmember Controlla se e' stata raggiunta l'inizio del file // (se

= 0 dell'intera relazione, altrimenti del file indicato ) bool bof( int logicnum = 0) const { return lfile(logicnum).bof(); } // @cmember Ritorna lo stao del file indicato (se

= 0 dell'intera relazione, // altrimenti del file indicato ) bool status(int logicnum = 0) const { return lfile(logicnum).status(); } // @cmember Controlla se l'ultima operazione sul file e' stat effettuata correttamente // (se

= 0 dell'intera relazione, altrimenti del file indicato ) bool good( int logicnum = 0) const { return lfile(logicnum).good(); } // @cmember Controlla se l'ultima operazione sul file ha generato un errore // (se

= 0 dell'intera relazione, altrimenti del file indicato ) bool bad( int logicnum = 0) const { return lfile(logicnum).bad(); } // @cmember Controlla se e' il file e' vuoto // (se

= 0 dell'intera relazione, altrimenti del file indicato ) bool empty( int logicnum = 0) const { return lfile(logicnum).empty(); } // @cmember Controlla se la relazione e' corretta bool isconsistent (bool reset = FALSE); // @cmember Controlla se c'e' un record ed e' il primo match (non si e' mai fatta // ) bool is_first_match(int logicnum); // @cmember Ritorna il numero di files collegati int items() { return _reldefs.items(); } // @cmember Salva la posizione attuale di tutti i file della relazione void save_status () ; // @cmember Ripristina la posizione attuale di tutti i file della relazione void restore_status () ; // positioning operators. return status // @cmember Sposta il puntatore corrente di

posizioni in avanti // (ritorna lo stato) TRecnotype operator +=(const TRecnotype npos) { return skip(npos); } // @cmember Sposta il puntatore corrente di

posizioni in dietro // (ritorna lo stato) TRecnotype operator -=(const TRecnotype npos) { return skip(-npos); } // @cmember Sposta il puntatore corrente di una posizione in avanti // (ritorna lo stato) TRecnotype operator ++() { return next(); } // @cmember Sposta il puntatore corrente di una posizione in dietro // (ritorna lo stato) TRecnotype operator --() { return prev(); } // @cmember Costruttore dal numero logico del file TRelation(int logicnum); // @cmember Costruttore dal nome della tabella TRelation(const char* tabname); // @cmember Costruttore dal nome del file TRelation(TLocalisamfile* f); // @cmember Distruttore virtual ~TRelation(); }; /////////////////////////////////////////////////////////// // TRecord_Array /////////////////////////////////////////////////////////// // @doc EXTERNAL // @class TRecord_array | Classe per la gestione di un array di record // // @base public | TArray class TRecord_array : private TArray // @author:(INTERNAL) Guido // @access:(INTERNAL) Private Member { // @cmember:(INTERNAL) Numero logico del file principale int _file; // @cmember:(INTERNAL) Offset iniziale del record array int _offset; // @cmember:(INTERNAL) Nome del campo col numero di riga TString16 _num; // @access Protected Member protected: // @cmember Ritorna il numero riga del record

int rec2row(const TRectype& r) const; // @cmember Ritorna il nome del campo con numero di riga const TString& num_field() const { return _num; } // @cmember Elimina il record di posizione

(ritorna il risultato dell'operazione) int remove_from(int i) const; // @cmember Confronta i campi della chiave 1 scartando l'ultimo bool good(const TRectype& rec) const; // @access Public Member public: // @cmember Ritorna il record che fa da chiave per tutti gli altri const TRectype& key() const; // @cmember Ritorna il numero di righe presenti int rows() const { return items()-1; } // @cmember Ritorna la riga successiva non vuota a prtire da

int succ_row(int r) const { return succ(r - _offset) + _offset; } // @cmember Ritorna la riga precedente non vuota a prtire da

int pred_row(int r) const { return pred(r - _offset) + _offset; }; // @cmember Ritorna l'ultma riga non vuota int last_row() const { return last() + _offset; } // @cmember Ritorna la prima riga non vuota int first_row() const { return succ_row(0); } // @cmember Ritorna il record

-esimo const TRectype& row(int r) const { CHECKD(r > _offset, "Bad record number ", r); return (const TRectype&)operator[](r - _offset); } // @cmember Controlla se esiste la riga

(TRUE se esiste) bool exist(int r) const; // @cmember Ritorna la riga

TRectype& row(int r, bool create); // @cmember Inserisce una riga alla posizione indicata nel record, sposta gli altri elementi se la poszione era gia' occupata virtual int insert_row(TRectype* r); // @cmember Inserisce una riga alla posizione indicata nel record, sposta gli altri elementi se la poszione era gia' occupata int insert_row(const TRectype& r) { return insert_row((TRectype*)r.dup()); } // @cmember Aggiunge/sostituisce una riga alla posizione indicata nel record virtual int add_row(TRectype* r); // @cmember Aggiunge/sostituisce una riga alla posizione indicata nel record int add_row(const TRectype& r) { return add_row((TRectype*)r.dup()); } // @cmember Compatta le righe piene virtual void pack() ; // @cmember Cancella una riga identificata da

virtual bool destroy_row(int n, bool pack = FALSE); // @cmember Cancella una riga identificata da

virtual bool destroy_row(const TRectype& r, bool pack = FALSE) { return destroy_row(rec2row(r), pack); } // @cmember Cancella tutte le righe void destroy_rows(); // @cmember Ritorna il numero logico del file principale int logic_num() const { return _file; } // @cmember Cambia l'intera chiave (solo se vuoto) void set_key(TRectype* r); // @cmember Rinumera il campo chiave in seguito a reinsert bool renum_key(const char* field, const TString& num); // @cmember Rinumera il campo chiave in seguito a reinsert bool renum_key(const char* field, long num); // @cmember Legge tutto l'array dal file virtual int read(const TRectype& r); // @cmember Legge tutto l'array dal file virtual int read(TRectype* r); // @cmember Aggiorna il file (se

== TRUE allora viene aggiornato il record se esisteva) virtual int write(bool re = FALSE) const; // @cmember Aggiorna il record sul file virtual int rewrite() const { return write(TRUE); } // @cmember Cancella tutti i record dal file virtual int remove() const; // @cmember Costruttore TRecord_array(const TRectype& r, const char* numfield, int first = 1); // @cmember Costruttore TRecord_array(int logicnum, const char* numfield, int first = 1); // @cmember Costruttore TRecord_array(const TRecord_array& a); }; class TExpression; // @doc EXTERNAL // @type FILTERFUNCTION | Prototipo funzione che controlla se il record debba essere incluso nel cursore typedef bool (*FILTERFUNCTION)(const TRelation* r); // @doc EXTERNAL // @class TCursor | Classe per la definizione di un cursore su di una relazione // // @base public | TContainer class TCursor : public TContainer // @author:(INTERNAL) Villa // @access:(INTERNAL) Private Member { // @cmember:(INTERNAL) Relazione su cui costruire il cursore TRelation* _if; // @cmember:(INTERNAL) Chiave del file principale int _nkey; // @cmember:(INTERNAL) Posizione corrente TRecnotype _pos; // @cmember:(INTERNAL) Numero totale di record che verificano il filtro TRecnotype _totrec; // @cmember:(INTERNAL) Numero dell'ultimo record TRecnotype _lastrec; // @cmember:(INTERNAL) Chiave dell'ultimo record TRecnotype _lastkrec; // @cmember:(INTERNAL) Nome assoluto del file principale TFilename _filename; // @cmember:(INTERNAL) Filtro definito con la TString _filter; // @cmember:(INTERNAL) Nome della chive iniziale TString _keyfrom; // @cmember:(INTERNAL) Nome della chiave finale TString _keyto; // @cmember:(INTERNAL) Espressione del filtro relativo TExpression* _fexpr; // @cmember:(INTERNAL) Indica se e' stata messa in attesa (non puo' essere modificato) bool _frozen; // @cmember:(INTERNAL) Flag che permette l'update della relazione per l'espressione-filtro bool _filter_update; // @cmember:(INTERNAL) Flag che permette l'update della relazione per la funzione-filtro bool _filterfunction_update; // @cmember:(INTERNAL) Funzione filtro FILTERFUNCTION _filterfunction; // @cmember:(INTERNAL) Nome del file indice TFilename _indexname; // @cmember:(INTERNAL) Crea (o aggiorna) effettivamente l'indice del cursore TRecnotype update(); // @access Protected Member protected: // @cmember Apre il file di indice FILE* open_index(bool create = FALSE); // @cmember Ritorna se e' stato modificato il cursore (cioe' quando occorre fare l'update) virtual bool changed(); // @cmember Costruisce il cursore a partire dal record virtual TRecnotype buildcursor(TRecnotype rp); // @cmember Permette di creare una pagina di cursori virtual int filtercursor(int pagecnt, TRecnotype* page); // @cmember Posiziona il cursore in modo che il record corrente corriponda alla // posizione dell'indice temporaneo TRecnotype readrec(); // @cmember Setta il filtro sul cursore void filter(const char* filter, const TRectype* from = NULL, const TRectype* to = NULL); // @cmember Indica se e' possibile fare l'update sulla relazione (se e' possibile // sia sull'espressione-filtro che sulla funzione-filtro) bool update_relation() {return (_filter_update || _filterfunction_update);} // @access Public Member public: // @cmember Si sposta alla posizione

TRecnotype operator =(const TRecnotype nr); // @cmember Si sposta di

posizioni dalla corrente in avanti TRecnotype operator +=(const TRecnotype nr); // @cmember Si sposta di

posizioni dalla corrente in dietro TRecnotype operator -=(const TRecnotype npos) { return operator +=(-npos); } // @cmember Ritorna il primo oggetto del cursor TObject* first_item( ) { operator =( 0 ); return &curr( ); } // @cmember Ritorna l'oggetto del cursor successivo al corrente TObject* succ_item( ) { operator +=( 1 ); return &curr( ); } // @cmember Ritorna l'oggetto del cursor precedente al corrente TObject* pred_item( ) { operator -=( 1 ); return &curr( );} // @cmember Ritorna l'ultimo oggetto del cursor TObject* last_item( ) { operator =( items( ) -1 ); return &curr( ); } // @cmember Ritorna il n8umero di oggetti del cursor long objects( ) { return items( ); } // @cmember Ritorna la posizione corrente TRecnotype& pos() { return _pos; } // @cmember Ritorna il numero totale di record TRecnotype items(); // @cmember Ritorna la dimensione del file principale TRecnotype size() const { return file().eod(); } // @cmember Ritorna il nome della chiave iniziale const TString& from() const { return _keyfrom; } // @cmember Ritorna il nome della chiave finale const TString& to() const { return _keyto; } // @cmember Ritorna il descrittore del file principale TRectype& curr(int log = 0) const { return _if->curr(log); } // @cmember Ritorna il descrittore della tabella TRectype& curr(const char * tab) const { return _if->lfile(tab).curr(); } // @cmember Legge il record TRecnotype read(TIsamop op = _isgteq, TReclock lockop = _nolock, TDate& atdate = (TDate&)botime); // @cmember Mette un lock sul record int lock(TReclock = _lock); // @cmember Toglie un lock sul record (chiama ) int unlock() { return lock(_unlock); } // @cmember Controlla che si tratti di un oggetto valido virtual bool ok() const; // @cmember Ritorna il filtro const char* filter() const { return _filter; } // @cmember Permette di mettere in attesa il cursore void freeze(bool on = TRUE) { _frozen = on; } // @cmember Controlla se il cursore e' congelato bool frozen() const { return _frozen; } // @cmember Permette di modificare l'espressione-filtro void setfilter(const char* filter_expr, bool update=FALSE) { filter(filter_expr); _filter_update = update; } // @cmember Setta la regione-filtro dal record

al record

void setregion(const TRectype& from, const TRectype& to) { filter(NULL,&from, &to); } // @cmember Ritorna la relazione del cursore TRelation* relation() const { return _if; } // @cmember Ritorna il file della relazione con numero logico

TLocalisamfile& file(int lnum = 0) const { return _if->lfile(lnum); } // @cmember Ritorna il file della relazione con nome

TLocalisamfile& file(const char* name) const { return _if->lfile(name); } // @cmember Riposiziona l'albero delle relazione (chiama ) int repos() { return _if->position_rels(); } // @cmember Ritorna l'espressione-filtro TExpression* expression() const { return _fexpr; } // @cmember Ritorna la funzione-filtro FILTERFUNCTION filterfunction() const { return _filterfunction; } // @cmember Setta la chiave del file principale alla chiave del cursore void setkey() { file().setkey(_nkey); } // @cmember Setta la chiave del file principale alla chiave del cursore void setkey(int nkey); // @cmember Ritorna la chiave del cursor int key() const { return _nkey; } // @cmember Posizione il numero logico sul record successivo (chiama ) bool next_match(int lognum, const char* fl = NULL, int nk = 0); // @cmember Controlla se c'e' un record ed e' il primo match (chiama ) bool is_first_match(int ln); // @cmember Setta la fuzione-filtro void set_filterfunction(FILTERFUNCTION ff, bool update=FALSE) { _filterfunction = ff; _lastrec = 0L; _filterfunction_update = update;} // @cmember Controllla se esiste un fuiltro sul cursor bool has_filter() const { return _filter.not_empty() || _filterfunction; } // @cmember Salva la posizione attuale di tutti i file del cursore void save_status () { _if->save_status(); } // @cmember Ripristina la posizione attuale di tutti i file del cursore void restore_status () { _if->restore_status(); } // @cmember Costruttore TCursor(TRelation* f, const char* filter = "", int key = 1, const TRectype* from = NULL, const TRectype* to = NULL); // @cmember Distruttore virtual ~TCursor(); }; // @doc EXTERNAL // @class TSorted_cursor | Costruisce e gestisce un cursore ordinato per chiavi diverse da quelle specificate nel file. class TSorted_cursor : public TCursor // @author:(INTERNAL) Angelo // @comm Il formato dell'espressione deve essere: [LF->]FIELDNAME[[from,to]][+-]... Inoltre tutta l'espressione puo' essere racchiusa // dall'operatore UPPER(), per controlli non case-sensitive. //

e' il nome del campo per quale si vuole effettuare il sort, LF indica il numero logico del file (appartenente alla relazione!). //

e

sono parametri opzionali usati per specificare un sottocampo. Per default prende l'intera lunghezza. //

e

sono parametri opzionali usati per specificare il tipo di ordinamento:

significa crescente,

significa // decrescente. Per default l'ordinamento e' crescente. E' cosi' possibile creare chiavi con campi non appartententi al // file principale della relazione. // Es. "CODCF-TIPOCFSOTTOCONTO+UPPER(20->RAGSOC[1,40]-)" // @access:(INTERNAL) Private Member { // @cmember:(INTERNAL) Espressione per l'ordinamento TToken_string _order_expr; // @cmember:(INTERNAL) Puntatore all'oggetto per ordinare il cursore (vedi ) TSort* _sort; // @cmember:(INTERNAL) Indica se l'espressione e' cambiata bool _is_changed_expr; // @cmember:(INTERNAL) Indica se l'espressione e' valida bool _is_valid_expr; // @access Protected Member protected: // @cmember Controlla la validita' dell'espressione bool check_expr(TString& s); // @cmember Controlla se la singola espressione contiene l'operatore UPPER(), ritornandone l'argomento bool is_upper(TString& s); // @cmember Costruisce il cursore a partire dal record (vedi ) virtual TRecnotype buildcursor(TRecnotype rp); // @cmember Permette di creare una pagina di cursori (vedi ) virtual int filtercursor(int pagecnt, TRecnotype* page); // @cmember Ritorna se e' stato modificato il cursore (cioe' quando occorre fare l'update) (vedi ) virtual bool changed(); // @access Public Member public: // @cmember Si sposta alla posizione

TRecnotype operator =(const TRecnotype nr) {return TCursor::operator =(nr); } // @cmember Permette di cambiare l'ordinamento del cursore. void change_order(const char* order_expr); // @cmember Costruttore TSorted_cursor(TRelation *f,const char * order_expr, const char * filter = "", int key = 1, const TRectype* from = NULL, const TRectype* to = NULL); // @cmember Distruttore virtual ~TSorted_cursor(); }; // @doc EXTERNAL // @class TFieldref | Classe per la definizione di riferimenti ad un campo di una relazione // // @base public | TObject class TFieldref : public TObject // @author:(INTERNAL) Guido // @access:(INTERNAL) Private Member { // @cmember:(INTERNAL) Numero del file short _fileid; // @cmember:(INTERNAL) Nome tabella o stringa col numero del file TString _id; // @cmember:(INTERNAL) Nome del campo TString _name; // @cmember:(INTERNAL) Sottostringa di partenza int _from; // @cmember:(INTERNAL) Sottostringa di arrivo int _to; // @access Protected Member protected: // @cmember Stampa l'oggetto virtual void print_on(ostream& out) const; // @cmember Duplica l'oggetto TFieldref virtual TObject* dup() const; // @access Public Memeber public: // @cmember Costruttore TFieldref(); // @cmember Costruttore TFieldref(const TString&, short defid); // @cmember Operatore di assegnamento TFieldref& operator =(const TString& s); // @cmember Controlla la validita' dell'oggetto (TRUE se il numero del file e' valido) virtual bool ok() const { return _name.not_empty(); } // @cmember Ritorna il numero del file int file() const { return _fileid; } // @cmember Setta il numerodel file void set_file(int f); // @cmember Ritorna il nome del campo const TString& name() const { return _name; } // @cmember Setta il nome del campo void set_name(const char* n) { _name = n; } // @cmember Setta

void set_from(int f) { if (f > 0) f--; else f = 0; _from = f; } // @cmember Setta

void set_to(int t) { _to = t; } // @cmember Ritorna

int from() const { return _from; } // @cmember Ritorna

int to() const { return _to; } // @cmember Ritorna la lunghezza del campo di

int len(TRectype &rec) const; // @cmember Cerca nella relazione il campo e ne ritorna il contenuto const char* read(const TRelation&) const; // @cmember Cerca nel record il campo e ne ritorna il contenuto const char* read(const TRectype&) const; // @cmember Cerca nella relazione il campo e vi scrive

void write(const char* val, TRelation&) const; // @cmember Cerca nel record il campo e vi scrive

void write(const char* val, TRectype& rec) const; }; int name2log(const char* name); // @doc INTERNAL // @class TRelation_description | Gestisce l'uso interattivo di una relazione (scelta campi, descrizione) // // @base public | TObject class TRelation_description : public TObject // @author:(INTERNAL) Guido // @access:(INTERNAL) Private Member { // @cmember:(INTERNAL) Relazione descritta TRelation* _rel; // @cmember:(INTERNAL) Nome dei files della relazione TString_array _files; // @cmember:(INTERNAL) Array di campi TArray _fields; // @cmember:(INTERNAL) Numero logico del file corrente int _cur_file; // @cmember:(INTERNAL) Numero del campo corrente int _cur_field; // @cmember:(INTERNAL) UNUSED bool _menu; // @cmember:(INTERNAL) File corrente TToken_string _cfile; // @cmember:(INTERNAL) Campo corrente TToken_string _cfield; // @access Protected Member protected: // @cmember Inizializza l'array di stringhe con i nomi dei files void init_files_array(); // @cmember Legge la relazione void read_rel(); // @access Public Member public: // @cmember Controlla se si tratta di un oggetto valido (se il numero dei files e' di 0) virtual bool ok() const { return _files.items() > 0; } public: // @cmember Seleziona il file

bool choose_file (int id = 0); // @cmember Setta come file corrente quello con numero logico

bool set_cur_file(int id = 0); // @cmember Seleziona il campo

del file selezionato bool choose_field(const char* fld = ""); // @cmember Costruisce un menu' bool build_menu(const char* title = "Database"); // @cmember Rimuove il menu' costruito con bool remove_menu(); // @cmember Ritorna il numero logico del file selezionato (vedi ) int file_num(); // @cmember Ritorna la descrizione del file selezionato (vedi ) const char* file_desc(); // @cmember Setta la descrizione del file selezionato void file_desc(const char* desc); // @cmember Setta la descrizione del campo bool set_field_description(const char* field, const char* des); // @cmember Ritorna la descrizione del campo const char* get_field_description(const char* field); // @cmember Ritorna la descrizione del campo selezionato (vedi ) const char* field_desc(); // @cmember Setta la descrizione del campo selezionato void field_desc(const char* desc); // @cmember Riorna il nome del campo selezionato (vedi ) const char* field_name(); // @cmember Riorna la lunghezza del campo selezionato (vedi ) int field_len(); // @cmember Riorna il tipo del campo selezionato (vedi ) TFieldtypes field_type(); // @cmember Ritorna l'array di tutti nomi dei files const TString_array& get_all_desc() const { return _files; } // @cmember Cambia la relazione descritta void change_relation(TRelation& rel, TString_array& arr); // @cmember Stampa l'oggetto virtual void print_on(ostream& out) const; // @cmember Costruttore TRelation_description(TRelation& r); // @cmember Distruttore virtual ~TRelation_description(); // @devnote Domani o doman l'altro gestira' l'editing interattivo e grafico }; #endif // ** EOF relation.h