campo-sirio/include/isam.h

#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);

// @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 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 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 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;

  // @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 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();
};

// @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) ;
  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);
  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);

  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
  char _name[32];
  // @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) Sottocampo (Es. G1:TOTDOC) 
  char * _subfield;
  // @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 set(int from, int to);
  void get_subfield(char * 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())


void get_idx_names(int logicnum, TToken_string& i_names); 
void set_autoload_new_files(bool on);

#endif // __ISAM_