824 lines
28 KiB
C++
Executable File
824 lines
28 KiB
C++
Executable File
#ifndef __ISAM_H
|
|
#define __ISAM_H
|
|
|
|
#ifndef __SYSFLD_H
|
|
#include <sysfld.h>
|
|
#endif
|
|
|
|
#ifndef __ARRAY_H
|
|
#include <array.h>
|
|
#endif
|
|
|
|
#ifndef __ASSOC_H
|
|
#include <assoc.h>
|
|
#endif
|
|
|
|
#ifndef __SYSFLD_H
|
|
#include <sysfld.h>
|
|
#endif
|
|
|
|
#ifndef FOXPRO
|
|
|
|
#ifndef __REAL_H
|
|
#include <real.h>
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#ifndef __DATE_H
|
|
#include <date.h>
|
|
#endif
|
|
|
|
#ifndef __STRINGS_H
|
|
#include <strings.h>
|
|
#endif
|
|
|
|
#ifndef __FILES_H
|
|
#include <files.h>
|
|
#endif
|
|
|
|
#ifndef __LFFILES_H
|
|
#include <lffiles.h>
|
|
#endif
|
|
|
|
#ifndef __TEXT_H
|
|
class TTextfile;
|
|
#endif
|
|
|
|
#define FIELDERR -1
|
|
|
|
#define RECORD_NON_FISICO (-1L)
|
|
|
|
const int MAX_KEYS = 8;
|
|
|
|
class TLocalisamfile;
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @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 TIsamtempfile
|
|
friend class TIsamtempfile;
|
|
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Puntatore all'inizio del record
|
|
char* _rec;
|
|
// @cmember:(INTERNAL) Numero logico del record
|
|
int _logicnum;
|
|
// @cmember:(INTERNAL) Lunghezza del record
|
|
int _length;
|
|
// @cmember:(INTERNAL) Indica se il record e' vuoto
|
|
bool _isempty;
|
|
// @cmember:(INTERNAL) Indentificatore della tabella
|
|
char _tab[5];
|
|
// @cmember:(INTERNAL) Campo "COD" della tabella
|
|
TRecfield * _cod;
|
|
TBit_array * _memo_dirty;
|
|
TString_array * _memo_data;
|
|
TRecnotype _memo_recno;
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @cmember Segnalazione di un campo inesistente
|
|
virtual void unknown_field(const char* name) const;
|
|
// @cmember Compara due tipo di record del file (vedi <c TSortable>)
|
|
virtual int compare(const TSortable& s) const;
|
|
// @cmember Ritorna il nome dell'ultimo campo chiave identificato da <p key>
|
|
const char* last_key_field(int key) const;
|
|
// @cmember Ritorna il contenuto del campo <p nf>-esimo
|
|
const char* start(int nf) const;
|
|
// @cmember Permette di settare il valore di <p _isempty>
|
|
void setempty(bool val)
|
|
{ _isempty = val;}
|
|
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> (non tipizzata)
|
|
virtual const TString & get_str(const char* fieldname) const ;
|
|
// @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
|
|
virtual void put_str(const char* fieldname, const char* val);
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @cmember Duplica il tipo di record
|
|
virtual TObject* dup() const;
|
|
|
|
// @cmember Legge il file <p f> 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 <p field> della chiave principale con il valore <p val>
|
|
virtual void renum_key(const char* field, const char* val);
|
|
|
|
// @cmember Ritorna il numero di campi del record
|
|
int items() const;
|
|
// @cmember Setta il record come non vuoto (chiama <mf TRectype::setempty>)
|
|
void setdirty()
|
|
{ setempty(FALSE); }
|
|
// @cmember Setta il codice della tabella utilizzata
|
|
void settab(const char *tab);
|
|
// @cmember Ritorna il puntatore all'inizio del record. NON dovrebbe essere usata!
|
|
char* string() const
|
|
{ return _rec;}
|
|
|
|
// @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' stato cancellato
|
|
bool isdeleted() const
|
|
{ return *_rec == '*';}
|
|
// @cmember Ritorna la lunghezza del record
|
|
int len() const
|
|
{ return _length;}
|
|
// @cmember Ritorna il tipo del campo <p fieldname>
|
|
virtual TFieldtypes type(const char* fieldname) const;
|
|
// @cmember Ritorna la lunghezza del campo <p fieldname>
|
|
virtual int length(const char* fieldname) const;
|
|
// @cmember Ritorna numero di decimali del campo <p fieldname>
|
|
virtual int ndec(const char* fieldname) const;
|
|
// @cmember Indica se esiste il campo <p fieldname>
|
|
virtual bool exist(const char* fieldname) const;
|
|
// @cmember Ritorna il nome del campo <p i>-esimo
|
|
const char* fieldname(int i) const;
|
|
|
|
// @cmember Setta la chiave <p key>-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 <mf TRectype::compare_key>)
|
|
bool same_key(const TRectype& rec, int key = 1, int skip_last = 0) const
|
|
{ return compare_key(rec, key, skip_last) == 0; }
|
|
|
|
#ifndef FOXPRO
|
|
// @cmember Ritorna il reference al contenuto del campo <p fieldname>
|
|
const TString& get(const char* fieldname) const ;
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> in formato int
|
|
int get_int(const char* fieldname) const ;
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> in formato long
|
|
long get_long(const char* fieldname) const ;
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> in formato word
|
|
word get_word(const char* fieldname) const ;
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> in formato char
|
|
char get_char(const char* fieldname) const ;
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> in formato boolean
|
|
bool get_bool(const char* fieldname) const ;
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> 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 <p fieldname> in formato data
|
|
TDate get_date(const char* fieldname) const ;
|
|
|
|
#ifndef FOXPRO
|
|
// @cmember Setta il contenuto del campo <p fieldname> in formato int
|
|
void put(const char* fieldname, int val);
|
|
// @cmember Setta il contenuto del campo <p fieldname> in formato long
|
|
void put(const char* fieldname, long val);
|
|
// @cmember Setta il contenuto del campo <p fieldname> in formato word
|
|
void put(const char* fieldname, word val);
|
|
// @cmember Setta il contenuto del campo <p fieldname> in formato data
|
|
void put(const char* fieldname, const TDate& val);
|
|
// @cmember Setta il contenuto del campo <p fieldname> in formato carattere
|
|
void put(const char* fieldname, char val);
|
|
// @cmember Setta il contenuto del campo <p fieldname> in formato boolean
|
|
void put(const char* fieldname, bool val);
|
|
// @cmember Setta il contenuto del campo <p fieldname> in formato reale
|
|
void put(const char* fieldname, const real& val);
|
|
// @cmember Setta il contenuto del campo <p fieldname> in formato memo
|
|
void put(const char* fieldname, TTextfile& txt);
|
|
// @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
|
|
void put(const char* fieldname, const char* val) { put_str(fieldname, val); }
|
|
#endif
|
|
|
|
// @cmember Vuota il campo puntato da <p fieldname>
|
|
virtual void zero(const char * fieldname);
|
|
// @cmember Vuota tutto il record usando il carattere <p c>
|
|
virtual void zero(char c = '\0');
|
|
|
|
// @cmember Riempie il campo <p fieldname> di spazi
|
|
void blank(const char * fieldname)
|
|
{ put(fieldname, " "); }
|
|
|
|
// @cmember Assegnazione tra TRectype
|
|
virtual TRectype & operator =(const TRectype& rec);
|
|
// @cmember Assegnazione tra TRectype
|
|
virtual TRectype & operator =(const char* rec);
|
|
// @cmember Assegnazione tra TRectype
|
|
TRectype& operator =(const TBaseisamfile& f);
|
|
|
|
|
|
// @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 <p numkey>
|
|
const char* key(int numkey = 1) const;
|
|
// @cmember Ritorna se si tratta di un record valido
|
|
bool ok() const
|
|
{ return _rec != NULL; }
|
|
|
|
virtual void init_memo(const TRecnotype recno = RECORD_NON_FISICO);
|
|
virtual void write_memo(isdef * file, const TRecnotype recno);
|
|
bool has_memo() const { return _memo_data != NULL; }
|
|
void memo_recno (const TRecnotype recno = RECORD_NON_FISICO) { _memo_recno = recno; }
|
|
|
|
// @cmember Costruttore Costruisce un record staccato da un file.
|
|
// Sarebbe meglio utilizzare una delle altre due
|
|
TRectype(int logicnum);
|
|
// @cmember Costruttore. Costruisce il record e lo associa al file isam <p i>
|
|
TRectype(const TBaseisamfile* i);
|
|
// @cmember Costruttore. Costruisce il record a partire da <p r>
|
|
TRectype(const TRectype& r);
|
|
|
|
// @cmember Distruttore
|
|
virtual ~TRectype();
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TBaseisamfile | Classe per la definizione del file isam di base
|
|
//
|
|
// @base public | TObject
|
|
class TBaseisamfile : public TObject
|
|
|
|
// @author:(INTERNAL) Sandro
|
|
|
|
{
|
|
// @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;
|
|
// friend TRecnotype __buildcursor(TFilecursor* tic, TRecnotype rp);
|
|
// friend TRecnotype __filtercursor(TFilecursor* tic);
|
|
// friend bool __evalcondition(TBaseisamfile* i,TString& condition);
|
|
// friend void __readrec(TFilecursor* tic);
|
|
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Descrittore del file isam
|
|
isdef* _isamfile;
|
|
// @cmember:(INTERNAL) Numero logico del record corrente
|
|
int _logicnum;
|
|
// @cmember:(INTERNAL) Ultimo errore
|
|
int _lasterr;
|
|
// @cmember:(INTERNAL) Permette di sapere se rimuovere il record alla fine
|
|
bool _delrec;
|
|
// @cmember:(INTERNAL) Permette di sapere se rimuovere il record alla fine dalla lista interna di record
|
|
bool _delopenrec;
|
|
// @cmember:(INTERNAL) Puntatore a record corrente
|
|
TRectype* _current;
|
|
// @cmember:(INTERNAL) UNUSED
|
|
TFile _hf;
|
|
// @cmember:(INTERNAL) UNUSED
|
|
TFile _hfhd;
|
|
// @cmember:(INTERNAL) Indica se il file e' archivio storico
|
|
bool _historicfile;
|
|
// @cmember:(INTERNAL) UNUSED
|
|
TRecnotype _lasthf;
|
|
// @cmember:(INTERNAL) Record corrente
|
|
TRecnotype _recno;
|
|
// @cmember:(INTERNAL) Indica se il file possiede dei campi memo
|
|
bool _has_memo;
|
|
|
|
|
|
|
|
|
|
// @cmember:(INTERNAL) UNUSED
|
|
int gethr(TRectype& rec, TDate& atdate);
|
|
// @cmember:(INTERNAL) Ritorna NOERR
|
|
int addhr(const TRectype& rec, TDate& atdate);
|
|
// @cmember:(INTERNAL) Ritorna NOERR
|
|
int rewhr(const TRectype& rec, TDate& atdate);
|
|
// @cmember:(INTERNAL) Ritorna NOERR
|
|
int delhr(const TRectype& rec, TDate& atdate);
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @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();
|
|
// @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:
|
|
// @cmember Sostituisce il record corrente del del file
|
|
void set_curr(TRectype * curr);
|
|
// @cmember Attiva la chiave <p nkey> sul file aperto
|
|
void setkey(int nkey);
|
|
// @cmember Ritorna la chiave attiva sul file aperto
|
|
int getkey() const;
|
|
// @cmember Setta la variabile <p _leaterr>
|
|
void setstatus(int status)
|
|
{ _lasterr = status; }
|
|
// @cmember Si posiziona sul primo record del file (vedi <t TReclock>)
|
|
virtual int first(word lockop = _nolock);
|
|
// @cmember Si posiziona sull'ultimo record del file (vedi <t TReclock>)
|
|
virtual int last(word lockop = _nolock);
|
|
// @cmember Si posiziona sul successivo record del file (vedi <t TReclock>)
|
|
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 <t TReclock>)
|
|
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 <t TReclock>)
|
|
virtual int reread(word lockop = _nolock, TDate& atdate = (TDate&)botime);
|
|
// @cmember Rilegge l'ultimo record letto e lo copia in <p rec> (vedi <t TReclock>)
|
|
virtual int reread(TRectype& rec, word lockop = _nolock, TDate& atdate = (TDate&)botime);
|
|
// @cmember Salta <p nrec> record dalla posizione corrente (vedi <t TReclock>)
|
|
virtual int skip(TRecnotype nrec, word lockop = _nolock);
|
|
// @cmember Legge il record (vedi <t TReclock> e <t TIsamop>)
|
|
virtual int read(word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime);
|
|
// @cmember Legge il record e lo copia in <p rec> (vedi <t TReclock> e <t TIsamop>)
|
|
virtual int read(TRectype& rec, word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime);
|
|
// @cmember Legge il record alla posizione <p nrec> (vedi <t TReclock>)
|
|
virtual int readat(TRecnotype nrec, word lockop = _nolock);
|
|
// @cmember Legge il record alla posizione <p nrec> e lo copia in <p rec> (vedi <t TReclock>)
|
|
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 <p rec>
|
|
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 <p rec>)
|
|
virtual int rewrite(const TRectype& rec, TDate& atdate = (TDate&)botime);
|
|
// @cmember Riscrive un record alla posizione <p nrec>
|
|
virtual int rewriteat(TRecnotype nrec);
|
|
// @cmember Riscrive un record alla posizione <p nrec> copiando da <p rec>
|
|
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 <p rec>
|
|
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;
|
|
|
|
// @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 variabile <p _lasterr>
|
|
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' stato raggiunto 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 <p _lasterr> 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 <p _lasterr> 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 ;
|
|
|
|
// @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
|
|
|
|
#ifndef FOXPRO
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> di tipo int
|
|
int get_int(const char* fieldname) const
|
|
{ return curr().get_int(fieldname);}
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> di tipo long
|
|
long get_long(const char* fieldname) const
|
|
{ return curr().get_long(fieldname);}
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> di tipo word
|
|
word get_word(const char* fieldname) const
|
|
{ return curr().get_word(fieldname);}
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> di tipo carattere
|
|
char get_char(const char* fieldname) const
|
|
{ return curr().get_char(fieldname);}
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> di tipo boolean
|
|
bool get_bool(const char* fieldname) const
|
|
{ return curr().get_bool(fieldname);}
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> di tipo real
|
|
real get_real(const char* fieldname) const
|
|
{ return curr().get_real(fieldname);}
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> di tipo memo (vedi <mf TRectype::get_memo>)
|
|
bool get_memo(const char* fieldname, TTextfile& txt)
|
|
{ return curr().get_memo(fieldname, txt); }
|
|
#endif
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> di tipo data
|
|
TDate get_date(const char* fieldname) const
|
|
{ return curr().get_date(fieldname);}
|
|
|
|
#ifndef FOXPRO
|
|
// @cmember Ritorna il contenuto del campo <p fieldname> (non tipizzata)
|
|
const TString& get(const char* fieldname) const
|
|
{ return curr().get(fieldname);}
|
|
|
|
// @cmember Setta il contenuto del campo <p fieldname> di tipo int
|
|
void put(const char* fieldname, int val)
|
|
{ curr().put(fieldname, val);}
|
|
// @cmember Setta il contenuto del campo <p fieldname> di tipo long
|
|
void put(const char* fieldname, long val)
|
|
{ curr().put(fieldname, val);}
|
|
// @cmember Setta il contenuto del campo <p fieldname> di tipo word
|
|
void put(const char* fieldname, word val)
|
|
{ curr().put(fieldname, val);}
|
|
// @cmember Setta il contenuto del campo <p fieldname> di tipo data
|
|
void put(const char* fieldname, const TDate& val)
|
|
{ curr().put(fieldname, val);}
|
|
// @cmember Setta il contenuto del campo <p fieldname> di tipo carattere
|
|
void put(const char* fieldname, char val)
|
|
{ curr().put(fieldname, val);}
|
|
// @cmember Setta il contenuto del campo <p fieldname> di boolean
|
|
void put(const char* fieldname, bool val)
|
|
{ curr().put(fieldname, val);}
|
|
// @cmember Setta il contenuto del campo <p fieldname> di tipo real
|
|
void put(const char* fieldname, const real& val)
|
|
{ curr().put(fieldname, val);}
|
|
// @cmember Setta il contenuto del campo <p fieldname> di tipo memo (vedi <mf TRectype::put_memo>)
|
|
void put(const char* fieldname, TTextfile& txt)
|
|
{ curr().put(fieldname, txt); }
|
|
#else
|
|
// @cmember Ritorna una stringa con il contenuto del campo <p fieldname>
|
|
const char* get_str(const char* fieldname) const
|
|
{ return (const char *) curr().get_str(fieldname);}
|
|
#endif
|
|
|
|
// @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
|
|
void put(const char* fieldname, const char* val)
|
|
{ curr().put(fieldname, val);}
|
|
|
|
// @cmember Vuota il contenuto del campo <p fieldname> nel record corrente (vedi <mf TRectype::zero>)
|
|
void zero(const char * fieldname)
|
|
{ curr().zero(fieldname);}
|
|
// @cmember Vuota il contenuto del record corrente
|
|
void zero()
|
|
{ curr().zero();}
|
|
// @cmember Vuota tutto il record corrente usando il carattere <p c>
|
|
void zero(char c)
|
|
{ curr().zero(c);}
|
|
// @cmember Riempie il campo <p fieldname> del record corrente di spazi
|
|
void blank(const char * fieldname)
|
|
{ curr().blank(fieldname); }
|
|
// @cmember Setta il record corrente con il contenuto del record <p rec>
|
|
TRectype& operator =(const TRectype& rec)
|
|
{ return curr() = rec;}
|
|
|
|
// @cmember Costruttore
|
|
TBaseisamfile(int logicnum, bool linkrecinst = FALSE);
|
|
// @cmember Distruttore
|
|
virtual ~TBaseisamfile();
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TIsamfile | Classe per la definizione delle operazione sul file isam
|
|
//
|
|
// @base public | TBaseisamfile
|
|
class TIsamfile : public TBaseisamfile
|
|
|
|
// @author:(INTERNAL) Sandro
|
|
{
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @cmember Aggiorna i flags associati al file
|
|
int flags(bool updateeod = FALSE);
|
|
// @cmember Apre un file di isam con lock (vedi <mf TBaseisamfile::_open>)
|
|
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();
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TSystemisamfile | Classe per la definizione delle funzione per la creazione di un file
|
|
// di isam
|
|
//
|
|
// @base public | TIsamfile
|
|
class TSystemisamfile : public TIsamfile
|
|
|
|
// @author:(INTERNAL) Sandro
|
|
|
|
{
|
|
// @access:(INTERNAL) Private Memebr
|
|
|
|
// @cmember:(INTERNAL) Array di campi che descrivono il record del file
|
|
TArray _flds;
|
|
// @cmember:(INTERNAL) Array di espressione
|
|
TArray _exps;
|
|
|
|
// @cmember:(INTERNAL) Recupera le conversioni logiche da effettuare sul file
|
|
bool getlcf(long flev);
|
|
// @cmember:(INTERNAL) Esegue la conversione del file. Ritorna il codice di errore.
|
|
int exec_convapp(long flev, const bool before);
|
|
// @cmember:(INTERNAL) Esegue la conversione sui record del file (utilizzando le espressione definite
|
|
// in fconv.ini)
|
|
void makelc(TRectype& rec);
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @cmember Costruisce un file isam di dimensione <p eox>
|
|
int build(TRecnotype eox);
|
|
// @cmember Estende un file preesistente alla dimensione <p eox>
|
|
int extend(TRecnotype eox);
|
|
// @cmember Calcola lo spazio che il file occuperebbe se venisse esteso a <p eox>
|
|
long size(TRecnotype eox);
|
|
// @cmember Esegue la conversione del tracciato record del file
|
|
int update(const TTrec& newrec, bool vis = TRUE);
|
|
|
|
// @cmember Esegue sia <mf TSystemisamfile::packfile> e <mf TSystemisamfile::packindex>
|
|
int pack(bool vis = TRUE, bool ask = TRUE);
|
|
// @cmember Rimuove fisicamente i record cancellati
|
|
int packfile(bool vis = TRUE);
|
|
// @cmember Rimuove fisicamente gli indici cancellati
|
|
int packindex(bool vis = TRUE, bool ask = TRUE);
|
|
|
|
// @cmember Importa un file ascii
|
|
int load(const char* from, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool extended = FALSE) ;
|
|
|
|
// @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);
|
|
|
|
// @cmember Costruttore
|
|
TSystemisamfile(int logicnum, bool linkrecinst = FALSE): TIsamfile(logicnum, linkrecinst)
|
|
{}
|
|
// @cmember Distruttore
|
|
virtual ~TSystemisamfile()
|
|
{}
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TLocalisamfile | Classe per la definizione di un isam file
|
|
//
|
|
// @base public | TBaseisamfile
|
|
class TLocalisamfile : public TBaseisamfile
|
|
|
|
// @author:(INTERNAL) Sandro
|
|
{
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
// @cmember:(INTERNAL) Indica se il file e' stato aperto come Localisamfile
|
|
bool _was_open;
|
|
// @cmember:(INTERNAL) Vecchia chiave se il file e' gia' aperto
|
|
int _oldkey;
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @cmember Apre il file con lock (vedi <mf TBaseisamfile::_open>)
|
|
int open(unsigned int mode = _manulock);
|
|
// @cmember Chiude il file aperto
|
|
int close() ;
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @cmember Avanza di <p npos> record
|
|
virtual int operator +=(const TRecnotype npos);
|
|
// @cmember Sposta indietro di <p npos> 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;}
|
|
|
|
// @cmember Costruttore. <p Linkrecinst> dice se il file deve utilizzare un area record
|
|
// separata oppure la stessa.
|
|
TLocalisamfile(int logicnum, bool linkrecinst = FALSE);
|
|
// @cmember Distruttore
|
|
virtual ~TLocalisamfile();
|
|
};
|
|
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @class TIsamtempfile | Classe per la definizione del file isam temporaneo
|
|
//
|
|
// @base public | TLocalisamfile
|
|
class TIsamtempfile : public TLocalisamfile
|
|
|
|
// @author:(INTERNAL) Sandro
|
|
{
|
|
|
|
// @access:(INTERNAL) Private Member
|
|
|
|
//@cmember:(INTERNAL) Indica se cancellare il file in chiusura
|
|
bool _autodel;
|
|
|
|
// @access Protected Member
|
|
protected:
|
|
// @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:
|
|
// @cmember Setta il valore di <p _autodel> a <p val>
|
|
void set_autodel(bool val=TRUE)
|
|
{_autodel = val;}
|
|
// @cmember Costruttore
|
|
TIsamtempfile(int logicnum, const char* radix, bool create);
|
|
// @cmember Distruttore
|
|
virtual ~TIsamtempfile();
|
|
};
|
|
|
|
// @doc EXTERNAL
|
|
|
|
// @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:
|
|
// @cmember Costruttore.
|
|
TRec_array(int dimension, TBaseisamfile& i);
|
|
};
|
|
|
|
// @class TRecfield | Classe per la gestione dei campi di un record
|
|
//
|
|
// @base public | TObject
|
|
class TRecfield : public TObject
|
|
|
|
// @author:(INTERNAL) Guido
|
|
|
|
// @access:(INTERNAL) Private Member
|
|
{
|
|
// @cmember:(INTERNAL) Nome del campo
|
|
char _name[12];
|
|
// @cmember:(INTERNAL) Puntatore a inizio record
|
|
TRectype* _rec;
|
|
// @cmember:(INTERNAL) Puntatore a inizio campo
|
|
char* _p;
|
|
// @cmember:(INTERNAL) Lunghezza del campo
|
|
byte _len;
|
|
// @cmember:(INTERNAL) Numero di decimali del campo
|
|
byte _dec;
|
|
// @cmember:(INTERNAL) Tipo del campo
|
|
TFieldtypes _type;
|
|
|
|
// @cmember:(INTERNAL) Setta il campo <p to>-esimo con i valori di <p from>-esimo
|
|
void set(int from, int to);
|
|
|
|
// @access Public Member
|
|
public:
|
|
// @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
|
|
|
|
// @cmember Operatore di estrazione per tipo intero
|
|
operator int() const ;
|
|
// @cmember Operatore di estrazione per tipo long
|
|
operator long() const ;
|
|
// @cmember const char * | operator const char* | | Operatore di estrazione per tipo carattere
|
|
operator const char*() const ;
|
|
// @cmember Operatore di estrazione per data
|
|
operator TDate() const ;
|
|
#ifndef FOXPRO
|
|
// @cmember const real | operator const real | | Operatore di estrazione per real
|
|
operator const real() const ;
|
|
#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;
|
|
|
|
// @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);
|
|
};
|
|
|
|
/*
|
|
|
|
class TTransaction
|
|
{
|
|
public:
|
|
// @FPUB
|
|
void begin();
|
|
void end(bool success = TRUE);
|
|
void abort() { end(FALSE);}
|
|
};
|
|
|
|
*/
|
|
|
|
#ifdef __ISAM_CPP
|
|
#define extern
|
|
#endif
|
|
|
|
extern TRectype** openrec;
|
|
extern void get_idx_names(int logicnum, TToken_string& i_names);
|
|
|
|
#undef extern
|
|
|
|
void set_autoload_new_files(bool on);
|
|
|
|
#endif // __ISAM_
|