From 6b0ab4cb09d7709748812267f204b68c40cc3421 Mon Sep 17 00:00:00 2001 From: andrea Date: Tue, 12 Dec 1995 17:47:56 +0000 Subject: [PATCH] Aggiunta documentazione in linea. git-svn-id: svn://10.65.10.50/trunk@2280 c028cbd2-c16b-5b4b-a496-9718f37d4682 --- include/isam.cpp | 132 ++++++++- include/isam.h | 712 ++++++++++++++++++++++++++++++++------------- include/rectypes.h | 101 +++++-- 3 files changed, 702 insertions(+), 243 deletions(-) diff --git a/include/isam.cpp b/include/isam.cpp index b6cf21ad7..5393abb42 100755 --- a/include/isam.cpp +++ b/include/isam.cpp @@ -60,13 +60,21 @@ HIDDEN void UNKNOWN_FIELD(int num, const char* name) HIDDEN bool __autoload = TRUE; +// @doc EXTERNAL //////////////////////////////////////////////////////////////////////////////////////////////////// // Funzioni implementate per la gestione file dati tramite Codebase //////////////////////////////////////////////////////////////////////////////////////////////////// // Inizio(@) -void get_idx_names(int logicnum, TToken_string& i_names) // Returns a Token_string with the index names. (Current prefix!) + + +// @func Ritorna una Token_string con in nome dell'indice +void get_idx_names( + int logicnum, // @parm Numero logico del file di cui riconoscere l'indice + TToken_string& i_names) // @parm Token_string in cui inserire il nome dell'indice + +// @comm Ritorna il nome con il prefisso corrente { long c = DB_getconf(); TDir d; @@ -374,8 +382,12 @@ HIDDEN int delkeys(isfdptr fd, char* record,long recno) //////////////////////////////////////////////////////////////////////////////////////////////////// // Fine(@) +// @func Setta il valore della variabile

+void set_autoload_new_files( + bool on) // @parm Valore da assegnare + +// @comm Il valore di

indica il caricamento dei valori standard dei file -void set_autoload_new_files(bool on) { __autoload = on; } @@ -1172,8 +1184,18 @@ void TBaseisamfile::indexoff() } +// @mfunc Apre il file isam di base con lock +// +// @rdesc Ritorna NOERR se e' riuscita ad aprire il file, altrimenti ritorna il numero di errore +// generato (vedi ). +int TBaseisamfile::_open( + unsigned int mode) // @parm Indica il modo di apertura del file (default _manulock) -int TBaseisamfile::_open(unsigned int mode) +// @comm Il parametro

puo' assumere i valori: +// +// @flag _manulock | Il lock dei record viene fatto manualmente +// @flag _exclock | Il file viene aperte in modo esclusivo +// @flag _autolock | Il lock dei record viene fatto in modo automatico { CHECKS(filehnd() == NULL, "File already open ", (const char*)filename()); @@ -1401,7 +1423,12 @@ TIsamfile::~TIsamfile() } -int TIsamfile::flags(bool updateeod) +// @cmember Aggiorna i flags associati al file +// +// @rdesc Ritorna NOERR se e' riuscita ad eseguiore l'operazione, altrimenti ritorna il numero +// di errore generato (vedi ). +int TIsamfile::flags( + bool updateeod) // @parm Indica se aggiornare anche l'EOD del file { TDir d; @@ -1488,8 +1515,18 @@ TIsamtempfile::~TIsamtempfile() close(); } +// @mfunc Apre il file +// +// @rdesc Ritorna NOERR se e' riuscita ad aprire il file, altrimenti ritorna il numero di errore +// generato (vedi ). +int TIsamtempfile::open( + const char* radix, // @parm Radice del path del file + bool create, // @parm Indica se va creatoun nuovo file (se FALSE il file esiste gia') + TRecnotype eod, // @parm Numero di record presenti nel file + TRecnotype eox) // @parm Numero di record da aggiungere al file -int TIsamtempfile::open(const char* radix, bool create, TRecnotype eod, TRecnotype eox) +// @comm Nel case

sia TRUE allora viene settato automaticamente il valore di

+// a TRUE, cioe' viene abilitata l'eliminazione del file in chiusura. { int err = NOERR; @@ -1664,7 +1701,15 @@ long TSystemisamfile::size(TRecnotype eox) } #ifndef FOXPRO -bool TSystemisamfile::exec_convapp(long flev, const bool before) +// @mfunc Esegue la conversione del file +// +// @rdesc Ritorna il rusultato dell'operazione +// +// @flag TRUE | Se la conversione e' stata effettuata correttamente +// @flag FALSE | Se è stato rilevato un errore durante la conversione (viene emesso un ) +bool TSystemisamfile::exec_convapp( + long flev, // @parm Livello a cui aggiornare l'archivio + const bool before) // @parm SANDRO??? { const char * const v = before ? "BCNV" : "ACNV"; @@ -1747,13 +1792,19 @@ void TSystemisamfile::makelc(TRectype& rec) } } -int TSystemisamfile::update(TTrec& newrec, bool vis) +// @mfunc Esegue la conversione del tracciato record del file +// +// @rdesc Ritorna il risulato della conversione, altrimenti il codice di errore generato +// (vedi ) +int TSystemisamfile::update( + TTrec& newrec, // @parm Nuovo tracciato record con cui aggiornare il file + bool vis) // @parm Indica se visualizzare lo stato dell'operazione { CHECKS(filehnd() == NULL, "Can't update open file", (const char*)filename()); CHECK(newrec.len() != 0, "Can't update to file with empty field info"); - TDir dir; + TDir dir; dir.get(num(), _unlock, _nordir, _sysdirop); const bool is_com = prefix().is_com(); @@ -1887,8 +1938,14 @@ int TSystemisamfile::update(TTrec& newrec, bool vis) return err; } +// @mfunc Rimuove fisicamente i record cancellati +// +// @rdesc Ritorna NOERR se l'operazione di compattamento e' riuscita, altrimenti il codice di +// di errore generato (vedi ). +int TSystemisamfile::packfile( + bool vis) // @parm Indica se visualizzare lo stato dell'operazione -int TSystemisamfile::packfile(bool vis) +// @xref { int err=NOERR; @@ -1906,8 +1963,14 @@ int TSystemisamfile::packfile(bool vis) return err; } +// @mfunc Rimuove fisicamente gli indici cancellati +// +// @rdesc Ritorna NOERR se l'operazione di compattamento e' riuscita, altrimenti il codice di +// di errore generato (vedi ). +int TSystemisamfile::packindex( + bool vis) // @parm Indica se visualizzare lo stato dell'operazione -int TSystemisamfile::packindex(bool vis) +// @xref { int err=NOERR; @@ -1944,7 +2007,19 @@ int TSystemisamfile::pack(bool vis) return err; } -int TSystemisamfile::load(const char* from, char fs, char fd, char rs, bool vis, bool extended) +// @mfunc Importa un file ascii +// +// @rdesc Ritorna NOERR se l'operazione di lettura e' riuscita, altrimenti il codice di +// di errore generato (vedi ). +int TSystemisamfile::load( + const char* from, // @parm Nome del file da importare + char fs, // @parm Carattere separatore di campo (default ) + char fd, // @parm Carattere delimitatore di campi (default '\\0') + char rs, // @parm Carattere separatore di record (default '\\n') + bool vis, // @parm Indica se visualizzare lo stato dell'operazione (default TRUE) + bool extended) // @parm SANDRO???(default FALSE) + +// @xref { FILE* fl = fopen(from, "r"); @@ -2121,7 +2196,20 @@ int TSystemisamfile::load(const char* from, char fs, char fd, char rs, bool vis, return err; } -int TSystemisamfile::dump(const char* to, int nkey, char fs, char fd, char rs, bool vis, bool withdeleted) +// @mfunc Esporta VERSO un file ascii. +// +// @rdesc Ritorna NOERR se l'operazione di esportazione e' riuscita, altrimenti il codice di +// di errore generato (vedi ). +int TSystemisamfile::dump( + const char* to, // @parm Nome del file verso quale esportare + int nkey, // @parm Numero della chiave di ordinamento con cui scaricare i dati (defualt 1) + char fs, // @parm Carattere seperatore di campo (defualt ) + char fd, // @parm Carattere delimitatore di campo (default '\\0') + char rs, // @parm Carattere separatore di record (default '\\n') + bool vis, // @parm Indica se visualizzare lo stato dell'operazione (defualt TRUE) + bool withdeleted) // @parm Indica se scaricare anche i record cancellati (dafault FALSE) + +// @xref { FILE* f = fopen(to, "w"); @@ -2353,7 +2441,18 @@ const char* TRectype::last_key_field(int key) const return rf.Name; } -int TRectype::compare_key(const TRectype& rec, int key, int skip_last) const +// @mfunc Confronta le chiavi di due record +// +// @rdesc Ritorna il risultato di una : +// +// @flag 0 | Se le due chiavi sono uguali +// @flag 0 | Se le due chiavi sono diverse +int TRectype::compare_key( + const TRectype& rec, // @parm Record di cui confrontare le chiavi + int key, // @parm Numero della chiave del presente record (defautl 1) + int skip_last) const // @parm Numero di campi di ignorare nella comparazione a partire dall'ultimo + +// @xref { TString256 key1= build_key(key); TString256 key2 = rec.build_key(key); @@ -2589,7 +2688,12 @@ bool TRectype::get_bool(const char* fieldname) const } -bool TRectype::get_memo(const char* fieldname, TTextfile& txt) const +// @mfunc Ritorna il contenuto di un campo memo +// +// @rdesc Ritorna sempre TRUE +bool TRectype::get_memo( + const char* fieldname, // @parm Nome del campo da cui estrarre il contenuto + TTextfile& txt) const // @parm Reference della variabile a cui assegnare il contenuto dell campo { TToken_string memo( get( fieldname ), '\n' ); int last = memo.items( ); diff --git a/include/isam.h b/include/isam.h index 1443fbd3c..cc91c11a4 100755 --- a/include/isam.h +++ b/include/isam.h @@ -45,504 +45,803 @@ class TTextfile; #endif -// @M #define FIELDERR -1 #define RECORD_NON_FISICO (-1L) const int MAX_KEYS = 8; -// @END class TLocalisamfile; class TRectype; +// @doc EXTERNAL + +// @class TMemo_info | Classe per la definizione dei campi Memo +// +// @base public | TObject class TMemo_info : public TObject +// @author(:INTERNAL) Sandro { - +// @access Private Member + + // @cmember Campi memo modificati TBit_array _dirty; + // @cmember Array di stringhe contenteti i campi memo TString_array _data; + // @cmember Numero di record sul file dati TRecnotype _recno; + // @cmember Record che possiede il campo memo const TRectype * _owner; +// @access Protected Member protected: + + // @cmember Ritorna il descrittore del record (vedi ) RecDes * rec_des( ) const; +// @access Public Member public: - - TRecnotype recno( ) const { return _recno; } + // @cmember Ritorna il numero di record sul file dati + TRecnotype recno( ) const + { return _recno; } + + // @cmember Ritorna il numero logico del record int num() const ; - void recno( TRecnotype r ){ _recno = r; } + // @cmember Setta il numero di record sul file dati + void recno( TRecnotype r ) + { _recno = r; } + // @cmember Setta il contenturo del campo memo

con

void put( const char * fieldname, const char * data ); + // @cmember Ritorna il contenturo del campo memo

con

TString& get( const char * fieldname ); + // @cmember Scrive fisicamente il campo memo sul file void write_data( isdef * def ); + // @cmember Ritorna TRUE se il campo memo

e' stato letto dal file bool memo_loaded( const char * fieldname ); + // @cmember Annula tuttle le modifiche sui campi memo (prima della scrittura sul file) void reset( ); + + // @cmember Costruttore TMemo_info( const TRectype * owner, const TRecnotype recno ); + // @cmember Costruttore TMemo_info( const TRectype * owner, TMemo_info& memoinfo); + // @cmember Distruttore virtual ~TMemo_info( ); }; -// @C -// Classe TRectype : public TObject -// -// Tipo record -// -// @END +// @class TRectype | Classe per la definizione del tipo di record del file +// +// @base public | TSortable class TRectype : public TSortable + +// @author(:INTERNAL) Sandro + { + // @cfriend TExtrectype friend class TExtrectype; + // @cfriend TRecfield friend class TRecfield; + // @cfriend TBaseisamfile friend class TBaseisamfile; + // @cfriend TLocalisamfile friend class TLocalisamfile; + // @cfriend TIsamtemp file friend class TIsamtempfile; - // DPRIV - char* _rec; // Puntatore a inizio record - int _logicnum; // Numero logico - int _length; // Lunghezza - bool _isempty; // Se il record e' vuoto - char _tab[5]; // identificatore della tabella - TRecfield * _cod; // campo "COD" della tabella - TMemo_info * _memoinfo; - // @END +// @access Private Member + // @cmember Puntatore all'inizio inizio del record + char* _rec; + // @cmember Numero logico del record + int _logicnum; + // @cmember Lunghezza del record + int _length; + // @cmember Indica se il record e' vuoto + bool _isempty; + // @cmember Indentificatore della tabella + char _tab[5]; + // @cmember Campo "COD" della tabella + TRecfield * _cod; + // @cmember Puntatore alla classe contenente i campi memo + TMemo_info * _memoinfo; + +// @access Protected Member protected: // TObject - virtual int compare(const TSortable& s) const; + // @cmember Compara due tipo di record del file (vedi ) + virtual int compare(const TSortable& s) const; + // @cmember Ritorna il nome dell'ultimo campo chiave identificato da

const char* last_key_field(int key) const; protected: + // @cmember Ritorna il contenuto del campo

-esimo const char* start(int nf) const; - void setempty(bool val) { _isempty = val;} // Rende vero is_empty + // @cmember Permette di settare il valore di

+ void setempty(bool val) + { _isempty = val;} +// @access Public Member public: // TObject - virtual TObject* dup() const; // Duplica record - + // @cmember Duplica il tipo di record + virtual TObject* dup() const; + + // @cmember Legge il file

con il tipo di record virtual int read(TBaseisamfile& f, word op = _isequal); + // @cmember Legge il prossimo record virtual int next(TBaseisamfile& f); + // @cmember Aggiunge il record al file virtual int write(TBaseisamfile& f) const; + // @cmember Riscrive il record sul file virtual int rewrite(TBaseisamfile& f) const; + // @cmember Elimina il record dal file virtual int remove(TBaseisamfile& f) const; + // @cmember Cambia il campo

della chiave principale con il valore

virtual void renum_key(const char* field, const char* val); +// @access Public Member public: - // FPUB + // @cmember Ritorna il numero di campi del record int items() const; - void setdirty() { setempty(FALSE); } + // @cmember Setta il record come non suoto (chiama + void setdirty() + { setempty(FALSE); } + // @cmember Setta il codice della tabella utilizzata void settab(const char *tab); - char* string() const { return _rec;} // Ritorna il puntatore all'inizio. NON dovrebbe essere usata! + // @cmember Ritorna il puntatore all'inizio del record. NON dovrebbe essere usata! + char* string() const + { return _rec;} - void discard() { *_rec = '*';} // Setta il flag di cancellazione - void recall() { *_rec = ' ';} // Ripristina il flag di cancellazione - bool isdeleted() const { return *_rec == '*';} // Chiede se e' cancellato - int len() const { return _length;} // Ritorna la lunghezza - TFieldtypes type(const char* fieldname) const; // Ritorna il tipo del campo - int length(const char* fieldname) const; // Ritorna lunghezza campo - int ndec(const char* fieldname) const; // Ritorna numero di decimali - bool exist(const char* fieldname) const; // Ritorna l'esistenza del campo - const char* fieldname(int i) const; // Ritorna il nome del campo i + // @cmember Setta il flag di cancellazione + void discard() + { *_rec = '*';} + // @cmember Ripristina il flag di cancellazione + void recall() + { *_rec = ' ';} + // @cmember Indica se il record corrente e' satto cancellato + bool isdeleted() const + { return *_rec == '*';} + // @cmember Ritorna la lunghezza del record + int len() const + { return _length;} + // @cmember Ritorna il tipo del campo

+ TFieldtypes type(const char* fieldname) const; + // @cmember Ritorna la lunghezza del campo

+ int length(const char* fieldname) const; + // @cmember Ritorna numero di decimali del campo

+ int ndec(const char* fieldname) const; + // @cmember Indica se esiste il campo

+ bool exist(const char* fieldname) const; + // @cmember Ritorna il nome del campo

-esimo + const char* fieldname(int i) const; + // @cmember Setta la chiave

-esima di ordinamento sul file const char* build_key(int key = 1) const; + // @cmember Confronta le chiavi di due record int compare_key(const TRectype& rec, int key = 1, int skip_last = 0) const; + // @cmember Ritorna TRUE se le chiavi di due record sono uguali (vedi ) bool same_key(const TRectype& rec, int key = 1, int skip_last = 0) const { return compare_key(rec, key, skip_last) == 0; } + // @cmember Ritorna il contenuto del campo

(non tipizzata) const char* get_str(const char* fieldname) const ; #ifndef FOXPRO + // @cmember Riotna il reference al contenuto del campo

const TString& get(const char* fieldname) const ; + // @cmember Ritorna il contenuto del campo

in formato int int get_int(const char* fieldname) const ; + // @cmember Ritorna il contenuto del campo

in formato long long get_long(const char* fieldname) const ; + // @cmember Ritorna il contenuto del campo

in formato long word get_word(const char* fieldname) const ; + // @cmember Ritorna il contenuto del campo

in formato char char get_char(const char* fieldname) const ; + // @cmember Ritorna il contenuto del campo

in formato boolean bool get_bool(const char* fieldname) const ; + // @cmember Ritorna il contenuto del campo

in formato real real get_real(const char* fieldname) const ; + // @cmember Ritorna il contenuto di un campo memo bool get_memo(const char* fieldname, TTextfile& txt) const ; #endif + // @cmember Ritorna il contenuto del campo

in formato data TDate get_date(const char* fieldname) const ; - // @DES Put tipizzata - // @FPUB - #ifndef FOXPRO + // @cmember Setta il contenuto del campo

in formato int void put(const char* fieldname, int val); + // @cmember Setta il contenuto del campo

in formato long void put(const char* fieldname, long val); + // @cmember Setta il contenuto del campo

in formato word void put(const char* fieldname, word val); + // @cmember Setta il contenuto del campo

in formato data void put(const char* fieldname, const TDate& val); + // @cmember Setta il contenuto del campo

in formato carattere void put(const char* fieldname, char val); + // @cmember Setta il contenuto del campo

in formato boolean void put(const char* fieldname, bool val); + // @cmember Setta il contenuto del campo

in formato reale void put(const char* fieldname, const real& val); + // @cmember Setta il contenuto del campo

in formato memo void put(const char* fieldname, TTextfile& txt); #endif - // @DES Put NON tipizzata - // @FPUB + // @cmember Setta il contenuto del campo

(non tipizzata) void put(const char* fieldname, const char* val); // void put(const char* fieldname, TString& val); - void zero(const char * fieldname); // Vuota campo puntato da fieldname - void zero(); // Vuota tutto il record - void zero(char c); // Vuota tutto il record usando il carattere c + // @cmember Vuota il campo puntato da

+ void zero(const char * fieldname); + // @cmember Vuota tutto il record + void zero(); + // @cmember Vuota tutto il record usando il carattere

+ void zero(char c); - void blank(const char * fieldname) { put(fieldname, " "); } // Riempie il campo di spazi + // @cmember Riempie il campo

di spazi + void blank(const char * fieldname) + { put(fieldname, " "); } - TRectype& operator =(const TRectype& rec); // assegnazione tra TRectype - TRectype& operator =(const char* rec); // assegnazione tra TRectype + // @cmember Assegnazione tra TRectype + TRectype& operator =(const TRectype& rec); + // @cmember Assegnazione tra TRectype + TRectype& operator =(const char* rec); + // @cmember Assegnazione tra TRectype TRectype& operator =(const TBaseisamfile& f); - virtual RecDes* rec_des() const; // Ritorna il descrittore del record - int num() const { return _logicnum;} // Ritorna il numero logico - bool empty() const {return _isempty;} // Ritorna se e' vuoto - bool valid() const {return _rec[0] == ' ';} // Ritorna se il record non e'cancellato - const char* key(int numkey = 1) const; // Ritorna l'espressione della chiave numero numkey - bool ok() const { return _rec != NULL; } + // @cmember Ritorna il descrittore del record + virtual RecDes* rec_des() const; + // @cmember Ritorna il numero logico del record + int num() const + { return _logicnum;} + // @cmember Ritorna se il record e' vuoto + bool empty() const + {return _isempty;} + // @cmember Ritorna se il record non e'cancellato + bool valid() const + {return _rec[0] == ' ';} + // @cmember Ritorna l'espressione della chiave numero

+ const char* key(int numkey = 1) const; + // @cmember Ritorna se si tratta di un record valido + bool ok() const + { return _rec != NULL; } - TRectype(int logicnum); // Costruisce un record staccato da un file. Bisogna poi chiamare linkfile(). Sarebbe meglio utilizzare una delle altre due - TRectype(const TBaseisamfile* i); // Costruisce record e lo associa al file isam i - TRectype(const TRectype& r); // Costruisce il record a partire da r + // @cmember Costruttore Costruisce un record staccato da un file. + // Sarebbe meglio utilizzare una delle altre due + TRectype(int logicnum); + // @cmember Costruttore. Costruisce record e lo associa al file isam

+ TRectype(const TBaseisamfile* i); + // @cmember Costruttore. Costruisce il record a partire da

+ TRectype(const TRectype& r); + // @cmember Distruttore virtual ~TRectype(); + // @cmember Inizializza la struttura di void init_memo_info(const TRecnotype recnum ); - TMemo_info& memo_info( ) const { CHECK( _memoinfo, "Tentativo di accesso ad una memoinfo vuota!" ); return *_memoinfo; } + // @cmember Ritora il refernce alla + TMemo_info& memo_info( ) const + { CHECK( _memoinfo, "Tentativo di accesso ad una memoinfo vuota!" ); return *_memoinfo; } + // @cmember Scrive le iunformazioni contenute in void write_memo_info( isdef * def ) const; - bool has_memo() const { return _memoinfo != NULL; } + // @cmember Indica se il record possiede un campo memo + bool has_memo() const + { return _memoinfo != NULL; } + }; -// @C -// Classe TBaseisamfile : public TObject +// @class TRectype | Classe per la definizione del file isam di base // -// File isam di base -// -// @END - +// @base public | TObject class TBaseisamfile : public TObject + +// @author(:INTERNAL) Sandro + +// @access Provate Member { - // @DPRIV - isdef* _isamfile; // Descrittore file isam - int _logicnum; // Numero logico del record corrente - int _lasterr; // Ultimo errore - bool _delrec; // Per sapere se rimuovere il record alla fine - bool _delopenrec; // Per sapere se rimuovere il record alla fine dalla lista interna di record - TRectype* _current; // Puntatore a record corrente - TFile _hf; - TFile _hfhd; - bool _historicfile; // Vero se il file e' archivio storico - TRecnotype _lasthf; - TRecnotype _recno; - bool _has_memo; + // @cmember Descrittore del file isam + isdef* _isamfile; + // @cmember Numero logico del record corrente + int _logicnum; + // @cmember Ultimo errore + int _lasterr; + // @cmember Permette di sapere se rimuovere il record alla fine + bool _delrec; + // @cmember Permette di sapere se rimuovere il record alla fine dalla lista interna di record + bool _delopenrec; + // @cmember Puntatore a record corrente + TRectype* _current; + // @cmember UNUSED + TFile _hf; + // @cmember UNUSED + TFile _hfhd; + // @cmember Indica se il file e' archivio storico + bool _historicfile; + // @cmember UNUSED + TRecnotype _lasthf; + // @cmember Record corrente + TRecnotype _recno; + // @cmember Indica se il file possiede dei campi memo + bool _has_memo; - friend class TRectype; - friend class TLocalisamfile; - friend class TIsamfile; - friend class TIsamtempfile; - friend class TRecfield; + // @cfriend TRectype + friend class TRectype; + // @cfriend TLocalisamfile + friend class TLocalisamfile; + // @cfriend TIsamfile + friend class TIsamfile; + // @cfriend TIsamtempfile + friend class TIsamtempfile; + // @cfriend TRecfield + friend class TRecfield; // friend class TCursor; - // @END - // @FPRIV + // friend TRecnotype __buildcursor(TFilecursor* tic, TRecnotype rp); // friend TRecnotype __filtercursor(TFilecursor* tic); // friend bool __evalcondition(TBaseisamfile* i,TString& condition); // friend void __readrec(TFilecursor* tic); + // @cmember UNUSED int gethr(TRectype& rec, TDate& atdate); + // @cmember Ritorna NOERR int addhr(const TRectype& rec, TDate& atdate); + // @cmember Ritorna NOERR int rewhr(const TRectype& rec, TDate& atdate); + // @cmember Ritorna NOERR int delhr(const TRectype& rec, TDate& atdate); +// access Protected Member protected: - // @FPROT - isdef** ptrfilehnd() const { return (isdef**) &_isamfile;} - void clearfilehnd() { _isamfile = NULL;} + // @cmember Ritorna il descrittore del file isam + isdef** ptrfilehnd() const + { return (isdef**) &_isamfile;} + // @cmember Assegna NULL al descrittore del file isam + void clearfilehnd() + { _isamfile = NULL;} + // @cmember UNUSED void recover(); - int _open(unsigned int mode = _manulock); // Apre isam file con lock + // @cmember Apre il file isam di base con lock + int _open(unsigned int mode = _manulock); + // @cmember Chiude il file isam di base int _close(); + // @cmember Ritorna il nome del file aperto const char* filename() const; +// @access Public Member public: - // @FPUB - void setkey(int nkey); // Attiva una chiave - int getkey() const; // Ritorna la chiave - void setstatus(int status) { _lasterr = status; } // Setta _lasterr + // @cmember Attiva la chiave

sul file aperto + void setkey(int nkey); + // @cmember Ritorna la chiave attiva sul file aperto + int getkey() const; + // @cmember Setta la variabiel

+ void setstatus(int status) + { _lasterr = status; } + // @cmember Si posiziona sul primo record del file (vedi ) virtual int first(word lockop = _nolock); + // @cmember Si posiziona sull'ultimo record del file (vedi ) virtual int last(word lockop = _nolock); + // @cmember Si posiziona sul successivo record del file (vedi ) virtual int next(word lockop = _nolock); + // @cmember Si posiziona sul successivo record del file (UNUSED) virtual int next(TDate& atdate); + // @cmember Si posiziona sul precedente record del file (vedi ) virtual int prev(word lockop = _nolock); + // @cmember Si posiziona sul precedente record del file (UNUSED) virtual int prev(TDate& atdate); + // @cmember Rilegge l'ultimo record letto (vedi ) virtual int reread(word lockop = _nolock, TDate& atdate = (TDate&)botime); + // @cmember Rilegge l'ultimo record letto e lo copia in

(vedi ) virtual int reread(TRectype& rec, word lockop = _nolock, TDate& atdate = (TDate&)botime); + // @cmember Salta

record dalla posizione corrente (vedi ) virtual int skip(TRecnotype nrec, word lockop = _nolock); + // @cmember Legge il record (vedi e ) virtual int read(word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime); + // @cmember Legge il record e lo copia in

(vedi e ) virtual int read(TRectype& rec, word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime); + // @cmember Legge il record alla posizione

(vedi ) virtual int readat(TRecnotype nrec, word lockop = _nolock); + // @cmember Legge il record alla posizione

e lo copia in

(vedi ) virtual int readat(TRectype& rec, TRecnotype nrec, word lockop = _nolock); + // @cmember Aggiunge un record virtual int write(TDate& atdate = (TDate&)botime); + // @cmember Aggiunge un record copiando da

virtual int write(const TRectype& rec, TDate& atdate = (TDate&)botime); + // @cmember Riscrive un record virtual int rewrite(TDate& atdate = (TDate&)botime); + // @cmember Riscrive un record (il record

) virtual int rewrite(const TRectype& rec, TDate& atdate = (TDate&)botime); + // @cmember Riscrive un record alla posizione

virtual int rewriteat(TRecnotype nrec); + // @cmember Riscrive un record alla posizione

copiando da

virtual int rewriteat(const TRectype& rec, TRecnotype nrec); + // @cmember Elimina il record virtual int remove(TDate& atdate = (TDate&)botime); + // @cmember Elimina il record copiando da

virtual int remove(const TRectype& rec, TDate& atdate = (TDate&)botime); + // @cmember Ritorna il numero logico del file sotto forma di stringa virtual const char* name() const; - TRecnotype recno() const { return _recno;} - int lock(); // Attiva lock di tutto il file - int unlock(); // Disattiva lock di tutto il file - void indexon(); // Accende gli indici - void indexoff(); // Spegne gli indici - int status() const { return _lasterr; } // Ritorna _lasterr - int is_valid(); // Ritorna 0 se il file e' valido - TRectype& curr() const {return *_current;} // Ritorna puntatore a record corrente - bool eof() const { return status() == _iseof || status() == _isemptyfile;} // Vero se siamo a fine file - bool bof() const { return status() == _isbof || status() == _isemptyfile;} // Vero se siamo a inizio file - bool good() const { return status() == NOERR;} // Vero se _lasterr non contiene codici d'errore - bool bad() const { return status() != NOERR;} // Vero se _lasterr contiene codici d'errore - bool empty(); // Vero se il file e' vuoto - int num() const { return _logicnum;} // Ritorna il numero logico del record corrente + // @cmember Ritorna il record corrente + TRecnotype recno() const + { return _recno;} + // @cmember Attiva lock di tutto il file + int lock(); + // @cmember Disattiva lock di tutto il file + int unlock(); + // @cmember Accende gli indici + void indexon(); + // @cmember Spegne gli indici + void indexoff(); + // @cmember Ritorna il valore della varaibile

+ int status() const + { return _lasterr; } + // @cmember Controlla se il file e' valido (ritorna 0 se il file e' valido) + int is_valid(); + // @cmember Ritorna il puntatore al record corrente + TRectype& curr() const + {return *_current;} + // @cmember Controlla se e' stata raggiunta la fine del file (TRUE se EOF) + bool eof() const + { return status() == _iseof || status() == _isemptyfile;} + // @cmember Controlla se e' stata raggiunta l'inizio del file (TRUE se BOF) + bool bof() const + { return status() == _isbof || status() == _isemptyfile;} + // @cmember Controlla se l'ultima operazione sul file e' stata effettuata correttamente + // (TRUE se

non contiene codici di errore) + bool good() const + { return status() == NOERR;} + // @cmember Controlla se l'ultima operazione sul file ha generato un errore + // (TRUE se

contiene codici di errore) + bool bad() const + { return status() != NOERR;} + // @cmember Controlla se il file e' vuoto (TRUE se vuoto) + bool empty(); + // @cmember Ritorna il numero logico del record corrente + int num() const + { return _logicnum;} + // @cmember Ritorna la descrizione del file corrente const char* description() const; + // @cmember Ritorna il numero di record contenuti nel file corrente TRecnotype eod() const ; - isdef* filehnd() const { return (isdef*) _isamfile;} // Ritorna l'handle del file isam nella tabella + // @cmember Ritorna l'handle del file isam nella tabella + isdef* filehnd() const + { return (isdef*) _isamfile;} + // @cmember Numero di records presenti nel file long items() const; // n.o di records nel file - // @DES Get tipizzata. Ritorna il contenuto del campo nei vari tipi - // @FPUB #ifndef FOXPRO + // @cmember Ritorna il contenuto del campo

di tipo int int get_int(const char* fieldname) const { return curr().get_int(fieldname);} + // @cmember Ritorna il contenuto del campo

di tipo long long get_long(const char* fieldname) const { return curr().get_long(fieldname);} + // @cmember Ritorna il contenuto del campo

di tipo word word get_word(const char* fieldname) const { return curr().get_word(fieldname);} + // @cmember Ritorna il contenuto del campo

di tipo carattere char get_char(const char* fieldname) const { return curr().get_char(fieldname);} + // @cmember Ritorna il contenuto del campo

di tipo boolean bool get_bool(const char* fieldname) const { return curr().get_bool(fieldname);} + // @cmember Ritorna il contenuto del campo

di tipo real real get_real(const char* fieldname) const { return curr().get_real(fieldname);} + // @cmember Ritorna il contenuto del campo

di tipo memo (vedi ) bool get_memo(const char* fieldname, TTextfile& txt) { return curr().get_memo(fieldname, txt); } #endif + // @cmember Ritorna il contenuto del campo

di tipo data TDate get_date(const char* fieldname) const { return curr().get_date(fieldname);} #ifndef FOXPRO + // @cmember Ritorna il contenuto del campo

(non tipizzata) const TString& get(const char* fieldname) const { return curr().get(fieldname);} + + // @cmember Setta il contenuto del campo

di tipo int void put(const char* fieldname, int val) { curr().put(fieldname, val);} + // @cmember Setta il contenuto del campo

di tipo long void put(const char* fieldname, long val) { curr().put(fieldname, val);} + // @cmember Setta il contenuto del campo

di tipo word void put(const char* fieldname, word val) { curr().put(fieldname, val);} + // @cmember Setta il contenuto del campo

di tipo data void put(const char* fieldname, const TDate& val) { curr().put(fieldname, val);} + // @cmember Setta il contenuto del campo

di tipo carattere void put(const char* fieldname, char val) { curr().put(fieldname, val);} + // @cmember Setta il contenuto del campo

di boolean void put(const char* fieldname, bool val) { curr().put(fieldname, val);} + // @cmember Setta il contenuto del campo

di tipo real void put(const char* fieldname, const real& val) - { curr().put(fieldname, val);} + { curr().put(fieldname, val);} + // @cmember Setta il contenuto del campo

di tipo memo (vedi ) void put(const char* fieldname, TTextfile& txt) { curr().put(fieldname, txt); } #else + // @cmember Ritorna una strinag con il contenuto del campo

const char* get_str(const char* fieldname) const { return curr().get_str(fieldname);} #endif - // @DES Put NON tipizzata - // @FPUB + // @cmember Setta il contenuto del campo

(non tipizzata) void put(const char* fieldname, const char* val) { curr().put(fieldname, val);} - void zero(const char * fieldname) { curr().zero(fieldname);} - void zero() { curr().zero();} - void zero(char c) { curr().zero(c);} - void blank(const char * fieldname) { curr().blank(fieldname); } - TRectype& operator =(const TRectype& rec) { return curr() = rec;} + // @cmember Vuota il contenuto del campo

nel recortd corrente (vedi ) + void zero(const char * fieldname) + { curr().zero(fieldname);} + // @cmember Vuota il contenturo del record corrente + void zero() + { curr().zero();} + // @cmember Vuota tutto il record corrente usando il carattere

+ void zero(char c) + { curr().zero(c);} + // @cmember Riempie il campo

del record corrente di spazi + void blank(const char * fieldname) + { curr().blank(fieldname); } + // @cmember Setta il record corrente con il contenuto del record

+ TRectype& operator =(const TRectype& rec) + { return curr() = rec;} + // @cmember Controlla se il file possiede dei campi memo bool has_memo( ); + // @cmember Costruttore TBaseisamfile(int logicnum, bool linkrecinst = FALSE); + // @cmember Distruttore virtual ~TBaseisamfile(); }; -// @C -// Classe TIsamfile : public TBaseisamfile -// -// File isam +// @class TIsamfile | Classe per la definizione delle operazione sul file isam // -// @END - +// @base public | TBaseisamfile class TIsamfile : public TBaseisamfile + +// @author(:INTERNAL) Sandro { + +// @access Public Member public: - // @FPUB + // @cmember Aggiorna i flags associati al file int flags(bool updateeod = FALSE); - int open(unsigned int mode = _manulock) { return _open(mode);} // Apre isam file con lock - int close() { return _close();} + // @cmember Apre un file di isam con lock (vedi ) + int open(unsigned int mode = _manulock) + { return _open(mode);} + // @cmember Chiude il file di isam + int close() + { return _close();} + // @cmember Costruttore TIsamfile(int logicnum, bool linkrecinst); + // @cmember Distruttore virtual ~TIsamfile(); }; -// @C -// Classe TSystemisamfile : public TBaseisamfile +// @class TSystemisamfile | Classe per la definizione delle funzione per la creazione di un file +// di isam // -// @END - +// @base public | TIsamfile class TSystemisamfile : public TIsamfile + +// @author(:INTERNAL) Sandro + { +// @access Private Memebr + + // @cmember Array di campi che descrivono il record del file TArray _flds; + // @cmember Array di espressione TArray _exps; + // @cmember Ritorna TRUE se la versione dell'archivio e' = di

bool getlcf(long flev); + // @cmember Esegue la conversione del file bool exec_convapp(long flev, const bool before); + // @cmember SANDRO??? void makelc(TRectype& rec); +// @access Public Member public: - // @FPUB - int build(TRecnotype eox); // Costruisce un file isam - int extend(TRecnotype eox); // Estende un file preesistente - long size(TRecnotype eox); // Calcola lo spazio che il file occuperebbe se venisse esteso a eox + // @cmember Costruisce un file isam di dimensione

+ int build(TRecnotype eox); + // @cmember Estende un file preesistente alla dimensione

+ int extend(TRecnotype eox); + // @cmember Calcola lo spazio che il file occuperebbe se venisse esteso a

+ long size(TRecnotype eox); + // @cmember Esegue la conversione del tracciato record del file int update(TTrec& newrec, bool vis = TRUE); - int pack(bool vis = TRUE); // Esegue packfile e packindex - int packfile(bool vis = TRUE); // Rimuove fisicamente i record cancellati - int packindex(bool vis = TRUE); // La stessa cosa sugli indici + // @cmember Esegue sia e + int pack(bool vis = TRUE); + // @cmember Rimuove fisicamente i record cancellati + int packfile(bool vis = TRUE); + // @cmember Rimuove fisicamente gli indici cancellati + int packindex(bool vis = TRUE); - // @DES Importa un file ascii. from e' il nome del file da importare + // @cmember Importa un file ascii int load(const char* from, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool extended = FALSE) ; - // @DES Esporta VERSO un file ascii. + // @cmember Esporta VERSO un file ascii. int dump(const char* to, int nkey = 1, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool withdeleted = FALSE); - TSystemisamfile(int logicnum, bool linkrecinst = FALSE) - : TIsamfile(logicnum, linkrecinst) {} - virtual ~TSystemisamfile() {} + // @cmember Costruttore + TSystemisamfile(int logicnum, bool linkrecinst = FALSE): TIsamfile(logicnum, linkrecinst) + {} + // @cmember Distruttore + virtual ~TSystemisamfile() + {} }; -// @C -// Classe TLocalisamfile : public TBaseisamfile +// @class TLocalisamfile | Classe per la definizione di un isam file // -// @END - +// @base public | TBaseisamfile class TLocalisamfile : public TBaseisamfile -{ - // @DPRIV - bool _was_open; // Vero se il file e' stato aperto come Localisamfile - int _oldkey; // Old key if already open +// @author(:INTERNAL) Sandro +{ +// @access Private Member + + // @cmember Indica se il file e' stato aperto come Localisamfile + bool _was_open; + // @cmember Vecchia chiave se il file e' gia' aperto + int _oldkey; + +// @access Protected Member protected: + // @cmember Apre il file con lock (vedi int open(unsigned int mode = _manulock); + // @cmember Chiude il file aperto int close() ; +// @access Public Member public: - // @FPUB - virtual int operator +=(const TRecnotype npos); // Avanza npos record - virtual int operator -=(const TRecnotype npos); // Sposta indietro di npos - virtual int operator ++(); // record successivo - virtual int operator --(); // record precedente - virtual bool tab() const { return FALSE;} // Ritorna vero se tabella + // @cmember Avanza di

record + virtual int operator +=(const TRecnotype npos); + // @cmember Spast indietro di

record + virtual int operator -=(const TRecnotype npos); + // @cmember Avanza al record successivo + virtual int operator ++(); + // @cmember Indietreggia al record precedente + virtual int operator --(); + // @cmember Ritorna TRUE se tabella + virtual bool tab() const + { return FALSE;} - // Costruttore. linkrecinst dice se il file deve utilizzare un area record separata oppure la stessa. + // @cmember Costruttore.

dice se il file deve utilizzare un area record + // separata oppure la stessa. TLocalisamfile(int logicnum, bool linkrecinst = FALSE); + // @cmember Distruttore virtual ~TLocalisamfile(); }; -// @C -// Classe TIsamtempfile : public TLocalisamfile -// -// File isam temporaneo -// -// @END TTrec +// @class TIsamtempfile | Classe per la definizione del file isam temporaneo +// +// @base public | TLocalisamfile class TIsamtempfile : public TLocalisamfile + +// @author(:INTERNAL) Sandro { - bool _autodel; // Settato a true se create = 2: cancella il file in chiusura - + +// @access Private Member + + //@cmember Indica se cancellare il file in chiusura + bool _autodel; + +// @access Protected Member protected: - // Apre il file. radix e' la radice del path del file, - // se create e' falso vuol dire che il file esiste gia', - // e allora eod dice quanti record ci sono; eox quanti bisogna aggiungerne + // @cmember Apre il file int open(const char* radix, bool create, TRecnotype eod, TRecnotype eox); + // @cmember Chiude il file int close(); +// @access Public Member public: - void set_autodel(bool val=TRUE) {_autodel = val;} + // @cmember Setta il valore di

a

+ void set_autodel(bool val=TRUE) + {_autodel = val;} + // @cmember Costruttore TIsamtempfile(int logicnum, const char* radix, bool create); + // @cmember Distruttore virtual ~TIsamtempfile(); }; -// @C -// Classe TRec_array : public TArray -// -// @END +// @class TRec_array | Classe per la definizione un array di record +// +// @base public | TArray class TRec_array : public TArray + +// @author(:INTERNAL) Sandro { +// @access Public Member public: - // @FPUB + // @cmember Costruttore. TRec_array(int dimension, TBaseisamfile& i); }; -// @C -// Classe TRecfield : public TObject +// @class TRecfield | Classe per la gestione dei campi di un record // -// @END - +// @base public | TObject class TRecfield : public TObject -{ - // @DPRIV - char _name[12]; // Nome campo - TRectype* _rec; // Puntatore a inizio record - char* _p; // Puntatore a inizio campo - byte _len; // Lunghezza campo - byte _dec; // Numero di decimali - byte _type; // Tipo del campo - // @END - // @FPRIV +// @access Private Member +{ + // @cmember Nome del campo + char _name[12]; + // @cmember Puntatore a inizio record + TRectype* _rec; + // @cmember Puntatore a inizio campo + char* _p; + // @cmember Lunghezza del campo + byte _len; + // @cmember Numero di decimali del campo + byte _dec; + // @cmember Tipo del campo + byte _type; + + // @cmember Setta il campo

-esimo con i valori di

-esimo void set(int from, int to); +// @access Public Member public: - // @FPUB - // @DES Operatore di assegnazione (=) per i vari tipi - // @FPUB - + // @cmember Operatore di assegnamento per tipo intero int operator =(int i) ; + // @cmember Operatore di assegnamento per tipo long long operator =(long l) ; + // @cmember Operatore di assegnamento per tipo data const TDate& operator =(const TDate& d) ; + // @cmember Operatore di assegnamento per tipo carattere const char* operator =(const char* s) ; #ifndef FOXPRO + // @cmember Operatore di assegnamento per tipo real const real& operator =(const real& r) ; -#endif // FOXPRO +#endif - // @DES Operatore di estrazione per i vari tipi - // @FPUB + // @cmember Operatore di estrazione per tipo intero operator int() const ; + // @cmember Operatore di estrazione per tipo long operator long() const ; + // @cmember Operatore di estrazione per tipo carattere operator const char*() const ; + // @cmember Operatore di estrazione per data operator TDate() const ; #ifndef FOXPRO + // @cmember Operatore di estrazione per real operator const real() const ; -#endif // FOXPRO +#endif + // @cmember Scrive un campo packed. Sarebbe meglio non usare mai campi packed. + void setptr(TRecnotype r); + // @cmember Legge un campo packed. Sarebbe meglio non usare mai campi packed. + TRecnotype ptr() const; - void setptr(TRecnotype r); // Scrive un campo packed. Sarebbe meglio non usare mai campi packed. - TRecnotype ptr() const; // Legge un campo packed. Sarebbe meglio non usare mai campi packed. - - const char* pos() const { return (const char*) _p;} // Ritorna un puntatore all'inizio del campo nel record. Dovrebbe essere protected! - int len() const { return (int) _len;} // Ritorna la lunghezza - int dec() const { return (int) _dec;} // Ritorna il numero di decimali - TFieldtypes type() const { return (TFieldtypes) _type;} // Ritorna il tipo del campo - TRectype& record() const { return *_rec;} // Ritorna puntatore a inizio record + // @cmember Ritorna un puntatore all'inizio del campo nel record. Dovrebbe essere protected! + const char* pos() const + { return (const char*) _p;} + // @cmember Ritorna la lunghezza del campo + int len() const + { return (int) _len;} + // @cmember Ritorna il numero di decimali del campo + int dec() const { return (int) _dec;} + TFieldtypes type() const + // @cmember Ritorna il tipo del campo + { return (TFieldtypes) _type;} + // @cmember Ritorna il puntatore a inizio record + TRectype& record() const + { return *_rec;} + // @cmember Costruttore TRecfield(TRectype& rec, const char* name, int from = 0, int to = -1); }; @@ -563,10 +862,9 @@ public: #define extern #endif -// @DPUB extern TRectype** openrec; extern void get_idx_names(int logicnum, TToken_string& i_names); -// @END + #undef extern void set_autoload_new_files(bool on); diff --git a/include/rectypes.h b/include/rectypes.h index 577898ed1..dbdf05f06 100755 --- a/include/rectypes.h +++ b/include/rectypes.h @@ -9,28 +9,85 @@ typedef long TRecnotype; // @END -enum TFilelock { _excllock = 0x100, _autolock = 0x200, - _manulock = 0x400}; -enum TReclock { _unlock = 0x1000, _nolock = 0x2000, _lock = 0x4000, - _testandlock = (int)0x8000} ; - enum TDirtype { _nordir, _comdir } ; - enum TDirop { _nordirop, _sysdirop }; -enum TFieldtypes { _nullfld, _alfafld, _intfld, _longfld, _realfld, - _datefld, _wordfld, _charfld, _boolfld , _intzerofld, _longzerofld, - _memofld} ; - enum TIsamop { _isfirst = 0x0, _islast = 0x1, _isnext= 0x2, - _isprev = 0x4, _iscurr = 0x8, _isequal = 0x10, - _isgreat = 0x20, _isgteq = 0x40, _isnextn = 0x100, - _isprevn = 0x200} ; - enum TIsamerr { _iseof = 201, _isbof = 202, _isfileovf = 203, - _iskeynotfound = 204, _isemptyfile = 205, - _isdupkey = 206, _isnocurkey = 207, - _iskeyrangeerr = 211, _iskeyerr = 212, - _iskeylenerr = 214, _ispatherr = 216, _ispathfull = 217, - _isnrecerr = 218, _isfilefull = 219, _isnotopen = 220, - _isnotcurr = 221, _isalropen = 222, _isdeadlock = 223, - _isreinsert = 224, _islocked = 225} ; - typedef long TRecnotype; + +// @doc EXTERNAL + +// @enum TFilelock | Comandi per l'apertura dei file +enum TFilelock { + _excllock = 0x100, // @emem Apertura in modo esclusivo + _autolock = 0x200, // @emem Apertura del file in modo auto + _manulock = 0x400}; // @emem Apertura del file in modo manuale + +// @enum TReclock | Comandi per la gestione dei lock su record +enum TReclock { + _unlock = 0x1000, // @emem Sblocca il record + _nolock = 0x2000, // @emem Nessuna operazione di lock + _lock = 0x4000, // @emem Blocca il record + _testandlock = (int)0x8000} ; // @emem Blocca il record se possibile, altrimenti ritorna errore + +// @enum TDirtype | Comandi per la gestione di +enum TDirtype { + _nordir, // @emem Riferimento operazioni col prefix corrente + _comdir } ; // @emem Riferimento operazioni al direttorio comune + +// @enum TDirop | Comandi per la gestione di +enum TDirop { + _nordirop, // @emem Riferimento per operazioni normali + _sysdirop }; // @emem Riferimento per operazioni di sistema + +// @enum TFieldtypes | Elenco tipi di campi +enum TFieldtypes { + _nullfld, // @emem Campo vuoto + _alfafld, // @emem Campo di tipo alfanumerico + _intfld, // @emem Campo di tipo intero + _longfld, // @emem Campo di tipo intero lungo + _realfld, // @emem Campo di tipo reale (vedi ) + _datefld, // @emem Campo di tipo data (vedi ) + _wordfld, // @emem Campo di tipo intero senza segno + _charfld, // @emem Campo di tipo carattere + _boolfld , // @emem Campo di tipo booleano + _intzerofld, // @emem Campo di tipo intero zero filled + _longzerofld, // @emem Campo di tipo intero lungo zero filled + _memofld} ; // @emem Campo di tipo memo + + +// @enum TIsamop | Comandi per eseguire operazioni di lettura sul file +enum TIsamop { + _isfirst = 0x0, // @emem Legge il primo record del file + _islast = 0x1, // @emem Legge l'ultimo record del file + _isnext= 0x2, // @emem Legge il prossimo record del file + _isprev = 0x4, // @emem Legge il precedente record del file + _iscurr = 0x8, // @emem Legge il record corrente del file (rilettura) + _isequal = 0x10, // @emem Legge il record con chiave uguale a quella specificata + _isgreat = 0x20, // @emem Legge il record con chiave maggiore di quella specificata + _isgteq = 0x40, // @emem Legge il record con chiave maggiore o uguale di quella specificata + _isnextn = 0x100, // @emem Legge i prossimi n record + _isprevn = 0x200} ; // @emem Legge i precedenti n record + +// @enum TIsamerr | Elenco codici di errore +enum TIsamerr { + _iseof = 201, // @emem End of file + _isbof = 202, // @emem Begin of file + _isfileovf = 203, // @emem Overflow del file + _iskeynotfound = 204, // @emem Chiave non trovata + _isemptyfile = 205, // @emem File vuoto + _isdupkey = 206, // @emem Chiave duplicata + _isnocurkey = 207, // @emem Non esiste la chiave corrente + _iskeyrangeerr = 211, // @emem Valore errato della chiave + _iskeyerr = 212, // @emem Errore generico della chiave + _iskeylenerr = 214, // @emem Lunghezza della chiave errata + _ispatherr = 216, // @emem File indice non coerente + _ispathfull = 217, // @emem UNUSED + _isnrecerr = 218, // @emem Errore sul numero dei record + _isfilefull = 219, // @emem File o disco pieno + _isnotopen = 220, // @emem File non aperto + _isnotcurr = 221, // @emem Non esiste il record corrente + _isalropen = 222, // @emem File gia' aperto + _isdeadlock = 223, // @emem Condizione di deadlock + _isreinsert = 224, // @emem Chiva duplicata su indici diversi da 1 + _islocked = 225} ; // @emem Record bloccato + +typedef long TRecnotype; #endif // __RECTYPES_H