2a3e35827d
Files correlati : ba1.exe Ricompilazione Demo : [ ] Commento : 0001036: installazione cd patch 180 Installando ex novo ed indicando una società esistente di dati su una cartella diversa viene segnalato l'errore ba1.exe in fase di conversione archivi, richiamando da manutenzione archivi la conversione vengono generati gli errori allegati. Nell'area ftp di Aga, cartella Ilaria allego l'area dati SIDA per il test. git-svn-id: svn://10.65.10.50/trunk@17971 c028cbd2-c16b-5b4b-a496-9718f37d4682
859 lines
32 KiB
C++
Executable File
859 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'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 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
|
||
long 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>
|
||
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 di dimensione <p eox> sulla base del tracciato <p r> passato
|
||
int build(TRecnotype eox, const TTrec& r);
|
||
// @cmember Costruisce un file isam di dimensione <p eox>.
|
||
int build(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 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) Sandro
|
||
{
|
||
// @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_
|