a0a98b13ff
Files correlati : Ricompilazione Demo : [ ] Commento : Aggiunto il metodo not_empty ai rectype git-svn-id: svn://10.65.10.50/branches/R_10_00@23219 c028cbd2-c16b-5b4b-a496-9718f37d4682
865 lines
32 KiB
C++
Executable File
865 lines
32 KiB
C++
Executable File
#ifndef __ISAM_H
|
||
#define __ISAM_H
|
||
|
||
#ifndef __CURRENCY_H
|
||
#include <currency.h>
|
||
#endif
|
||
|
||
#ifndef __DATE_H
|
||
#include <date.h>
|
||
#endif
|
||
|
||
#ifndef __FILES_H
|
||
#include <files.h>
|
||
#endif
|
||
|
||
#ifndef __LFFILES_H
|
||
#include <lffiles.h>
|
||
#endif
|
||
|
||
#ifndef __PREFIX_H
|
||
#include <prefix.h>
|
||
#endif
|
||
|
||
#define FIELDERR -1
|
||
|
||
#define RECORD_NON_FISICO (-1L)
|
||
|
||
const int MAX_KEYS = 8;
|
||
|
||
class TBaseisamfile;
|
||
class TLocalisamfile;
|
||
class TRecfield;
|
||
|
||
class TMemo_data : public TString_array
|
||
{
|
||
TBit_array _dirty;
|
||
TRecnotype _recno;
|
||
TIsam_handle _isamfile;
|
||
|
||
public:
|
||
void destroy();
|
||
void init(TRecnotype recno, TIsam_handle file);
|
||
TRecnotype recno() const { return _recno; }
|
||
TIsam_handle file() const { return _isamfile; }
|
||
void copy(const TMemo_data& m);
|
||
bool is_dirty(int i) const { return _dirty[i]; }
|
||
void set_dirty(int i, bool d = true) { _dirty.set(i, d); }
|
||
|
||
TMemo_data& operator=(const TMemo_data& m) { copy(m); return *this; }
|
||
TMemo_data(const TMemo_data& m) { copy(m); }
|
||
TMemo_data() : _recno(RECORD_NON_FISICO), _isamfile(0) { }
|
||
virtual ~TMemo_data() { }
|
||
};
|
||
|
||
// @doc EXTERNAL
|
||
|
||
// @class TRectype | Classe per la definizione del tipo di record del file
|
||
//
|
||
// @base public | TSortable
|
||
class TRectype : public TSortable
|
||
|
||
// @author:(INTERNAL) Alex
|
||
|
||
{
|
||
// @cfriend TRecfield
|
||
friend class TRecfield;
|
||
|
||
// @access Protected Member
|
||
protected:
|
||
|
||
// @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
|
||
TMemo_data* _memo_data;
|
||
|
||
// @access Protected Member
|
||
protected:
|
||
// @cmember Segnalazione di un campo inesistente
|
||
virtual void unknown_field(const char* name) 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);
|
||
|
||
bool set_edit_info(const char* ut, const char* dt, const char* or);
|
||
|
||
// @access Public Member
|
||
public:
|
||
// @cmember Duplica il tipo di record
|
||
virtual TObject* dup() const;
|
||
// @cmember Compara due tipo di record del file (vedi <c TSortable>)
|
||
virtual int compare(const TSortable& s) const;
|
||
|
||
// @cmember Legge il file <p f> con il tipo di record
|
||
virtual int read(TBaseisamfile& f, word op = _isequal, word lockop = _nolock);
|
||
// @cmember Legge il file <p f> con il tipo di record alla posizione desiderata
|
||
virtual int readat(TBaseisamfile& f, TRecnotype nrec, word lockop = _nolock);
|
||
// @cmember Legge il prossimo record
|
||
/* virtual*/ int next(TBaseisamfile& f, word lockop = _nolock);
|
||
int prev(TBaseisamfile& f, word lockop = _nolock);
|
||
int first(TBaseisamfile& f, word lockop = _nolock);
|
||
int last(TBaseisamfile& f, word lockop = _nolock);
|
||
// @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 Aggiunge/Aggiorna il record
|
||
virtual int write_rewrite(TBaseisamfile& f) const;
|
||
// @cmember Aggiorna/Aggiunge il record
|
||
virtual int rewrite_write(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; }
|
||
|
||
// @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 del campo <p fieldname> in formato data
|
||
TDate get_date(const char* fieldname) const ;
|
||
|
||
// @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 valuta
|
||
void put(const char* fieldname, const TCurrency& val);
|
||
// @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
|
||
void put(const char* fieldname, const char* val) { put_str(fieldname, val); }
|
||
|
||
#ifdef __LONGDOUBLE__
|
||
// @cmember Setta il contenuto del campo <p fieldname> in formato reale
|
||
void put(const char* fieldname, long double val)
|
||
{ put(fieldname, real(val)); }
|
||
#endif
|
||
// @cmember Incrementa il contenuto del campo <p fieldname> in formato reale
|
||
void add(const char* fieldname, const real& val);
|
||
|
||
// @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 const 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' vuoto
|
||
bool not_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
|
||
virtual bool ok() const
|
||
{ return _rec != NULL; }
|
||
// @cmember Ritorna true se sono uguali
|
||
bool is_equal(const TRectype& r) const;
|
||
|
||
virtual void init_memo(const TRecnotype recno = RECORD_NON_FISICO, TIsam_handle file = 0);
|
||
virtual void reset_memo() { _memo_data->init(RECORD_NON_FISICO, 0); }
|
||
virtual void write_memo(TIsam_handle file, const TRecnotype recno);
|
||
bool has_memo() const { return _memo_data != NULL; }
|
||
|
||
// Gestione posta elettronica
|
||
virtual void fill_transaction(TConfig& cfg, int row = 0) const;
|
||
bool send_mail(const char* action = "MODIFY") const;
|
||
|
||
// @cmember Ritorna la relapp che gestisce il file
|
||
virtual bool get_relapp(TString& app) const;
|
||
virtual bool edit(int logicnum = 0, const char * alternate_key_fields = NULL, const char* hint = NULL) const;
|
||
|
||
virtual bool set_modify_info();
|
||
virtual bool set_creation_info();
|
||
|
||
// @cmember Inizializza un record staccato da un file.
|
||
void init(int logicnum);
|
||
|
||
virtual word class_id() const { return CLASS_RECTYPE; }
|
||
virtual bool is_kind_of(word id) const { return id == class_id() || TSortable::is_kind_of(id); }
|
||
|
||
// @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) Alex
|
||
|
||
{
|
||
// @cfriend TRectype
|
||
friend class TRectype;
|
||
// @cfriend TCursor
|
||
friend class TCursor;
|
||
// @cfriend TSorted_cursor
|
||
friend class TSorted_cursor;
|
||
|
||
// @access Protected Member
|
||
protected:
|
||
|
||
// @cmember:(INTERNAL) Numero logico del record corrente
|
||
int _logicnum;
|
||
// @cmember:(INTERNAL) Isam handle
|
||
int _isam_handle;
|
||
// @cmember:(INTERNAL) Chiave corrente
|
||
int _curr_key;
|
||
// @cmember:(INTERNAL) Ultimo errore
|
||
int _lasterr;
|
||
// @cmember:(INTERNAL) Puntatore a record corrente
|
||
TRectype* _current;
|
||
// @cmember:(INTERNAL) Record corrente
|
||
TRecnotype _recno;
|
||
|
||
// @access Protected Member
|
||
protected:
|
||
// @cmember:(INTERNAL) IO su file:
|
||
virtual int _read(TRectype& rec, word op = _isequal, word lockop = _nolock);
|
||
virtual int _readat(TRectype& rec, TRecnotype nrec, word lockop = _nolock);
|
||
virtual int _write(const TRectype& rec);
|
||
virtual int _rewrite(const TRectype& rec);
|
||
virtual int _remove(const TRectype& rec);
|
||
|
||
// @cmember UNUSED
|
||
void recover();
|
||
// @cmember Apre il file isam di base con lock, permettendo di specificare se usare gli indici o no
|
||
int _open(unsigned int mode = _manulock, bool index = true);
|
||
int _open_ex(unsigned int mode = _manulock, bool index = true);
|
||
|
||
// @cmember Chiude il file isam di base
|
||
int _close();
|
||
|
||
// @cmember Ritorna il nome del file aperto
|
||
const char* filename() const;
|
||
|
||
// @cmember Costruttore per derivare TExternisamfile. <p Name> indica il file esterno da aprire.
|
||
TBaseisamfile(const char* name, const char* descname = NULL);
|
||
|
||
int handle(int key = 0) const;
|
||
|
||
// @access Public Member
|
||
public:
|
||
// @cmember Sostituisce il record corrente del del file
|
||
virtual 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 precedente record del file (vedi <t TReclock>)
|
||
virtual int prev(word lockop = _nolock);
|
||
// @cmember Rilegge l'ultimo record letto (vedi <t TReclock>)
|
||
virtual int reread(word lockop = _nolock);
|
||
// @cmember Rilegge l'ultimo record letto e lo copia in <p rec> (vedi <t TReclock>)
|
||
virtual int reread(TRectype& rec, word lockop = _nolock);
|
||
// @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);
|
||
// @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);
|
||
// @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();
|
||
// @cmember Aggiunge un record copiando da <p rec>
|
||
virtual int write(const TRectype& rec);
|
||
// @cmember Riscrive un record
|
||
virtual int rewrite();
|
||
// @cmember Riscrive un record (il record <p rec>)
|
||
virtual int rewrite(const TRectype& rec);
|
||
// @cmember Tenta di aggiungere un record ma se esiste gia' lo aggiorna
|
||
virtual int write_rewrite(const TRectype& rec);
|
||
virtual int write_rewrite();
|
||
// @cmember Tenta di aggiornare un record ma se non esiste lo crea
|
||
virtual int rewrite_write(const TRectype& rec);
|
||
virtual int rewrite_write();
|
||
// @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();
|
||
// @cmember Elimina il record copiando da <p rec>
|
||
virtual int remove(const TRectype& rec);
|
||
// @cmember Ritorna il numero logico del file sotto forma di stringa
|
||
virtual const char* name() const;
|
||
// @cmember Ritorna il modulo al quale appartiene la tabella
|
||
virtual const char* module() const;
|
||
|
||
// @cmember Ritorna il numero del record corrente
|
||
virtual 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(bool exclusive);
|
||
// @cmember Restituisce se il file <20> ordinato con indice esterno (default:false)
|
||
virtual bool is_sorted()
|
||
{return false;}
|
||
// @cmember Ritorna il puntatore al record corrente
|
||
virtual 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)
|
||
virtual bool empty();
|
||
// @cmember Ritorna il numero logico del record corrente
|
||
int num() const
|
||
{ return _logicnum;}
|
||
// @cmember Ritorna la descrizione del file corrente
|
||
virtual const char* description();
|
||
// @cmember Ritorna il numero di record contenuti nel file corrente
|
||
virtual TRecnotype eod() const ;
|
||
|
||
// @cmember Numero di records presenti nel file
|
||
virtual TRecnotype items() const; // n.o di records nel file
|
||
|
||
// @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 data
|
||
TDate get_date(const char* fieldname) const
|
||
{ return curr().get_date(fieldname);}
|
||
|
||
// @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 valuta
|
||
void put(const char* fieldname, const TCurrency& val)
|
||
{ curr().put(fieldname, val);}
|
||
|
||
#ifdef __LONGDOUBLE__
|
||
// @cmember Setta il contenuto del campo <p fieldname> in formato reale
|
||
void put(const char* fieldname, long double val)
|
||
{ curr().put(fieldname, real(val)); }
|
||
#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
|
||
virtual void zero() { curr().zero();}
|
||
// @cmember Vuota tutto il record corrente usando il carattere <p c>
|
||
virtual 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 Ritorna la relapp che gestisce il file
|
||
virtual bool get_relapp(TString& app) const;
|
||
|
||
// @cmember Testa se il file e' cambiato dal momento <p stat>
|
||
bool is_changed_since(long& stat) const;
|
||
|
||
virtual word class_id() const { return CLASS_BASEISAMFILE; }
|
||
virtual bool is_kind_of(word id) const { return id == class_id() || TObject::is_kind_of(id); }
|
||
|
||
// @cmember Costruttore
|
||
TBaseisamfile(int logicnum);
|
||
// @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, bool index = true)
|
||
{ return _open(mode, index); }
|
||
|
||
int open_ex(unsigned int mode = _manulock, bool index = true)
|
||
{ return _open_ex(mode, index); }
|
||
|
||
// @cmember Chiude il file di isam
|
||
int close()
|
||
{ return _close();}
|
||
|
||
virtual word class_id() const { return CLASS_ISAMFILE; }
|
||
virtual bool is_kind_of(word id) const { return id == class_id() || TBaseisamfile::is_kind_of(id); }
|
||
|
||
// @cmember Costruttore
|
||
TIsamfile(int logicnum);
|
||
// @cmember Distruttore
|
||
virtual ~TIsamfile();
|
||
};
|
||
|
||
typedef bool (*SELECTIONFUNCTION)(const TRectype & r, TObject * obj);
|
||
// @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);
|
||
// @cmember aggiorna l'eod e l'eox del file
|
||
void update_file();
|
||
|
||
// @access Public Member
|
||
public:
|
||
// @cmember Costruisce un file isam sulla base del tracciato <p r> passato
|
||
int build(const TTrec& r);
|
||
// @cmember Costruisce un file isam
|
||
int build();
|
||
// @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 interactive = false);
|
||
|
||
// @cmember Esegue sia <mf TSystemisamfile::packfile> e <mf TSystemisamfile::packindex>
|
||
int pack(bool vis = false, bool ask = true);
|
||
// @cmember Rimuove fisicamente i record cancellati
|
||
int packfile(bool vis = false, bool zap = false);
|
||
// @cmember Rimuove fisicamente gli indici cancellati
|
||
int packindex(bool vis = false, bool ask = true);
|
||
// @cmember Rimuove fisicamente tutti i records e gli indici
|
||
int zap();
|
||
|
||
// @cmember Importa un file ascii
|
||
int load(const char* from, char fs = '|', char fd = '\0', char rs = '\n', bool vis = true, bool extended = false, bool indexed = true) ;
|
||
int overwrite(const char* from, char fs = '|', char fd = '\0', char rs = '\n', bool vis = true) ;
|
||
|
||
// @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, const char * filter = NULL, SELECTIONFUNCTION select_func = NULL, TObject * filter_obj = NULL);
|
||
int dump(const char* to, TToken_string & field_list, int nkey = 1, char fs = '|', char fd = '\0', char rs = '\n', bool vis = true, bool withdeleted = false, const char * filter = NULL, SELECTIONFUNCTION select_func = NULL, TObject * filter_obj = NULL);
|
||
|
||
virtual word class_id() const { return CLASS_SYSTEMISAMFILE; }
|
||
virtual bool is_kind_of(word id) const { return id == class_id() || TIsamfile::is_kind_of(id); }
|
||
|
||
// @cmember Costruttore
|
||
TSystemisamfile(int logicnum): TIsamfile(logicnum)
|
||
{}
|
||
// @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) Alex
|
||
{
|
||
// @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() ;
|
||
|
||
// @cmember Costruttore per derivare TTempIsamfile
|
||
TLocalisamfile(int logicnum, bool tmp);
|
||
// @cmember Costruttore per derivare TExternisamfile. <p Name> indica il file esterno da aprire (vedi <c TBaseisamfile>).
|
||
TLocalisamfile(const char* name, const char* descname = NULL);
|
||
|
||
// @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;}
|
||
|
||
virtual word class_id() const { return CLASS_LOCALISAMFILE; }
|
||
virtual bool is_kind_of(word id) const { return id == class_id() || TBaseisamfile::is_kind_of(id); }
|
||
|
||
// @cmember Costruttore.
|
||
TLocalisamfile(int logicnum);
|
||
// @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) Alex
|
||
{
|
||
|
||
// @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;}
|
||
|
||
virtual word class_id() const { return CLASS_ISAMTEMPFILE; }
|
||
virtual bool is_kind_of(word id) const { return id == class_id() || TLocalisamfile::is_kind_of(id); }
|
||
|
||
// @cmember Costruttore
|
||
TIsamtempfile(int logicnum, const char* radix, bool create = true, bool autodel = false);
|
||
// @cmember Distruttore
|
||
virtual ~TIsamtempfile();
|
||
};
|
||
|
||
|
||
// @doc EXTERNAL
|
||
|
||
// @class TExternisamfile | Classe per la definizione del file isam esterno
|
||
//
|
||
// @base public | TLocalisamfile
|
||
class TExternisamfile : public TLocalisamfile
|
||
|
||
// @author:(INTERNAL) Angelo
|
||
{
|
||
//@cmember:(INTERNAL) Indica il nome del file col quale e' stata instanziata la classe
|
||
TFilename _name;
|
||
|
||
// @access Protected Member
|
||
protected:
|
||
// @cmember inizializza il file. <p exclusive> indica se aprire il file in modo esclusivo
|
||
void init(const char* name, bool exclusive, bool index);
|
||
// @cmember Apre il file. <p exclusive> indica se aprire il file in modo esclusivo
|
||
int open(bool exclusive, bool index = true);
|
||
// @cmember Chiude il file
|
||
int close();
|
||
|
||
// @access Public Member
|
||
public:
|
||
// @cmember Ritorna il nome del file sotto forma di stringa
|
||
virtual const char* name() const;
|
||
|
||
// @cmember Cancella tutti i record del file
|
||
int zap();
|
||
|
||
virtual word class_id() const { return CLASS_EXTERNISAMFILE; }
|
||
virtual bool is_kind_of(word id) const { return id == class_id() || TLocalisamfile::is_kind_of(id); }
|
||
|
||
// @cmember Costruttore. <p exclusive> indica se aprire il file in modo esclusivo.
|
||
// <p index> indica se aprire il file con indici o meno
|
||
TExternisamfile(const char* name, bool exclusive = false, bool index = true);
|
||
// @cmember Costruttore. <p descname> <20> il nome del file che contiene la descrizione del file (estensione trr).
|
||
// <p exclusive> indica se aprire il file in modo esclusivo.
|
||
// <p index> indica se aprire il file con indici o meno
|
||
TExternisamfile(const char* name, const char * descname, bool exclusive = false,
|
||
bool index = true);
|
||
// @cmember Distruttore
|
||
virtual ~TExternisamfile();
|
||
};
|
||
|
||
|
||
// @class TRecfield | Classe per la gestione dei campi di un record
|
||
//
|
||
// @base public | TObject
|
||
class TRecfield : public TObject
|
||
|
||
// @author:(INTERNAL) Alex
|
||
|
||
// @access:(INTERNAL) Private Member
|
||
{
|
||
// @cmember:(INTERNAL) Nome del campo e sottocampo (Es. G1:TOTDOC)
|
||
TString16 _name, _sub_field;
|
||
// @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) Da per i sottocampi (Es. G1:TOTDOC[2,3])
|
||
byte _from;
|
||
// @cmember:(INTERNAL) A per i sottocampi (Es. G1:TOTDOC[2,3])
|
||
byte _to;
|
||
|
||
// @cmember:(INTERNAL) Setta il campo <p to>-esimo con i valori di <p from>-esimo
|
||
void get_subfield(TString& s) const;
|
||
void put_subfield(const char * s);
|
||
|
||
// @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) ;
|
||
// @cmember Operatore di assegnamento per tipo real
|
||
const real& operator =(const real& r) ;
|
||
|
||
// @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 ;
|
||
// @cmember const real | operator const real | | Operatore di estrazione per real
|
||
operator const real() const ;
|
||
|
||
// @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 il nome del campo
|
||
const char* name() const { return _name; }
|
||
// @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;}
|
||
// @cmember Ritorna il tipo del campo
|
||
TFieldtypes type() const { return _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);
|
||
};
|
||
|
||
#define FOR_EACH_FILE_RECORD(isamfile) \
|
||
for (int _e##isamfile = isamfile.first(); \
|
||
_e##isamfile == NOERR; \
|
||
_e##isamfile = isamfile.next())
|
||
|
||
|
||
int get_table_names(int logicnum, TToken_string& i_names, int mode); // 1=dbf, 2=cdx, 4=fpt
|
||
void set_autoload_new_files(bool on);
|
||
|
||
#endif // __ISAM_H
|