campo-sirio/include/isam.h

#ifndef __ISAM_H
#define __ISAM_H

#ifndef __SYSFLD_H
#include <sysfld.h>
#endif 

#ifndef __ARRAY_H
#include <array.h>
#endif 

#ifndef __ASSOC_H
#include <assoc.h>
#endif 

#ifndef __SYSFLD_H
#include <sysfld.h>
#endif 

#ifndef FOXPRO

#ifndef __REAL_H
#include <real.h>
#endif

#endif

#ifndef __DATE_H
#include <date.h>
#endif 

#ifndef __STRINGS_H
#include <strings.h>
#endif 

#ifndef __FILES_H
#include <files.h>
#endif 

#ifndef __LFFILES_H
#include <lffiles.h>
#endif 
                
#ifndef __TEXT_H
class TTextfile;
#endif

#define FIELDERR -1

#define RECORD_NON_FISICO (-1L)

const int MAX_KEYS = 8;

class TLocalisamfile;

// @doc EXTERNAL

// @class TRectype | Classe per la definizione del tipo di record del file
//
// @base public | TSortable
class TRectype : public TSortable

// @author:(INTERNAL) Sandro

{
  // @cfriend TExtrectype
  friend class TExtrectype;
  // @cfriend TRecfield
  friend class TRecfield;
  // @cfriend TBaseisamfile
  friend class TBaseisamfile;
  // @cfriend TLocalisamfile
  friend class TLocalisamfile;
  // @cfriend TIsamtempfile
  friend class TIsamtempfile;

// @access:(INTERNAL) Private Member

  // @cmember:(INTERNAL) Puntatore all'inizio del record
  char* _rec;
  // @cmember:(INTERNAL) Numero logico del record
  int _logicnum;
  // @cmember:(INTERNAL) Lunghezza del record
  int _length;
  // @cmember:(INTERNAL) Indica se il record e' vuoto
  bool _isempty;
  // @cmember:(INTERNAL) Indentificatore della tabella
  char _tab[5];
  // @cmember:(INTERNAL) Campo "COD" della tabella 
  TRecfield * _cod;
  TBit_array *          _memo_dirty;
  TString_array *       _memo_data;
  TRecnotype            _memo_recno;

// @access Protected Member
protected:  
  // @cmember Segnalazione di un campo inesistente
  virtual void unknown_field(const char* name) const;                    
  // @cmember Compara due tipo di record del file (vedi <c TSortable>)
  virtual int compare(const TSortable& s) const;
  // @cmember Ritorna il nome dell'ultimo campo chiave identificato da <p key>
  const char* last_key_field(int key) const;
  // @cmember Ritorna il contenuto del campo <p nf>-esimo 
  const char* start(int nf) const;
  // @cmember Permette di settare il valore di <p _isempty>
  void setempty(bool val)
  { _isempty = val;}

  // @cmember Ritorna il contenuto del campo <p fieldname> (non tipizzata)
  virtual const TString & get_str(const char* fieldname) const ;
  // @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
  virtual void put_str(const char* fieldname, const char* val);

// @access Public Member
public:
  // @cmember Duplica il tipo di record
  virtual TObject* dup() const;

  // @cmember Legge il file <p f> con il tipo di record
  virtual int read(TBaseisamfile& f, word op = _isequal, 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);
  // @cmember Aggiunge il record al file
  virtual int write(TBaseisamfile& f) const;
  // @cmember Riscrive il record sul file
  virtual int rewrite(TBaseisamfile& f) const;
  // @cmember Elimina il record dal file
  virtual int remove(TBaseisamfile& f) const;
  // @cmember Cambia il campo <p field> della chiave principale con il valore <p val>
  virtual void renum_key(const char* field, const char* val);

  // @cmember Ritorna il numero di campi del record
  int items() const;
  // @cmember Setta il record come non vuoto (chiama <mf TRectype::setempty>)
  void setdirty()
  { setempty(FALSE); }
  // @cmember Setta il codice della tabella utilizzata
  void settab(const char *tab);
  // @cmember Ritorna il puntatore all'inizio del record. NON dovrebbe essere usata!
  char* string() const 
  { return _rec;}  

  // @cmember Setta il flag di cancellazione
  void discard()
  { *_rec = '*';}
  // @cmember Ripristina il flag di cancellazione
  void recall()
  { *_rec  = ' ';}
  // @cmember Indica se il record corrente e' stato cancellato
  bool isdeleted() const
  { return *_rec == '*';}
  // @cmember Ritorna la lunghezza del record
  int len() const
  { return _length;}
  // @cmember Ritorna il tipo del campo <p fieldname>
  virtual TFieldtypes type(const char* fieldname) const;
  // @cmember Ritorna la lunghezza del campo <p fieldname>
  virtual int length(const char* fieldname) const;
  // @cmember Ritorna numero di decimali del campo <p fieldname>
  virtual int ndec(const char* fieldname) const;
  // @cmember Indica se esiste il campo <p fieldname>
  virtual bool exist(const char* fieldname) const;
  // @cmember Ritorna il nome del campo <p i>-esimo
  const char* fieldname(int i) const;
  
  // @cmember Setta la chiave <p key>-esima di ordinamento sul file
  const char* build_key(int key = 1) const;
  // @cmember Confronta le chiavi di due record
  int compare_key(const TRectype& rec, int key = 1, int skip_last = 0) const;
  // @cmember Ritorna TRUE se le chiavi di due record sono uguali (vedi <mf TRectype::compare_key>)
  bool same_key(const TRectype& rec, int key = 1, int skip_last = 0) const 
  { return compare_key(rec, key, skip_last) == 0; }
  
#ifndef FOXPRO
  // @cmember Ritorna il reference al contenuto del campo <p fieldname>
  const TString& get(const char* fieldname) const ;
  // @cmember Ritorna il contenuto del campo <p fieldname> in formato int
  int get_int(const char* fieldname) const ;
  // @cmember Ritorna il contenuto del campo <p fieldname> in formato long
  long get_long(const char* fieldname) const ;
  // @cmember Ritorna il contenuto del campo <p fieldname> in formato word
  word get_word(const char* fieldname) const ;
  // @cmember Ritorna il contenuto del campo <p fieldname> in formato char
  char get_char(const char* fieldname) const ;
  // @cmember Ritorna il contenuto del campo <p fieldname> in formato boolean
  bool get_bool(const char* fieldname) const ;
  // @cmember Ritorna il contenuto del campo <p fieldname> in formato real
  real get_real(const char* fieldname) const ;
  // @cmember Ritorna il contenuto di un campo memo
  bool get_memo(const char* fieldname, TTextfile& txt) const ;
#endif
  // @cmember Ritorna il contenuto del campo <p fieldname> in formato data
  TDate get_date(const char* fieldname) const ;

#ifndef FOXPRO
  // @cmember Setta il contenuto del campo <p fieldname> in formato int
  void put(const char* fieldname, int val);
  // @cmember Setta il contenuto del campo <p fieldname> in formato long
  void put(const char* fieldname, long val);
  // @cmember Setta il contenuto del campo <p fieldname> in formato word
  void put(const char* fieldname, word val);
  // @cmember Setta il contenuto del campo <p fieldname> in formato data
  void put(const char* fieldname, const TDate& val);
  // @cmember Setta il contenuto del campo <p fieldname> in formato carattere
  void put(const char* fieldname, char val);
  // @cmember Setta il contenuto del campo <p fieldname> in formato boolean
  void put(const char* fieldname, bool val);
  // @cmember Setta il contenuto del campo <p fieldname> in formato reale
  void put(const char* fieldname, const real& val);
  // @cmember Setta il contenuto del campo <p fieldname> in formato memo
  void put(const char* fieldname, TTextfile& txt);
  // @cmember Setta il contenuto del campo <p fieldname> (non tipizzata)
  void put(const char* fieldname, const char* val) { put_str(fieldname, val); }
#endif 

#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 Vuota il campo puntato da <p fieldname>
  virtual void zero(const char * fieldname);
  // @cmember Vuota tutto il record usando il carattere <p c>
  virtual void zero(char c = '\0');

  // @cmember Riempie il campo <p fieldname> di spazi
  void blank(const char * fieldname)
  { put(fieldname, " "); }

  // @cmember Assegnazione tra TRectype
  virtual TRectype & operator =(const TRectype& rec);
  // @cmember Assegnazione tra TRectype
  virtual TRectype & operator =(const char* rec);
  // @cmember Assegnazione tra TRectype
  TRectype& operator =(const TBaseisamfile& f);


  // @cmember Ritorna il descrittore del record
  virtual RecDes * rec_des() const;
  // @cmember Ritorna il numero logico del record
  int num() const
  { return _logicnum;}
  // @cmember Ritorna se il record e' vuoto
  bool empty() const
  {return _isempty;}
  // @cmember Ritorna se il record non e'cancellato
  bool valid() const
  {return _rec[0] == ' ';}
  // @cmember Ritorna l'espressione della chiave numero <p numkey>
  const char* key(int numkey = 1) const;
  // @cmember Ritorna se si tratta di un record valido
  bool ok() const
  { return _rec != NULL; }

  virtual void init_memo(const TRecnotype recno  = RECORD_NON_FISICO);
  virtual void write_memo(isdef * file, const TRecnotype recno);
  bool has_memo() const { return _memo_data != NULL; } 
  void memo_recno (const TRecnotype recno = RECORD_NON_FISICO) { _memo_recno = recno; }
  
  // @cmember Costruttore Costruisce un record staccato da un file.
  //          Sarebbe meglio utilizzare una delle altre due
  TRectype(int logicnum);
  // @cmember Costruttore. Costruisce il record e lo associa al file isam <p i>
  TRectype(const TBaseisamfile* i);
  // @cmember Costruttore. Costruisce il record a partire da <p r>
  TRectype(const TRectype& r);

  // @cmember Distruttore
  virtual ~TRectype();
};

// @doc EXTERNAL

// @class TBaseisamfile | Classe per la definizione del file isam di base
//
// @base public | TObject
class TBaseisamfile : public TObject

// @author:(INTERNAL) Sandro

{
  // @cfriend TRectype
  friend class TRectype;
  // @cfriend TLocalisamfile
  friend class TLocalisamfile;
  // @cfriend TIsamfile
  friend class TIsamfile;
  // @cfriend TIsamtempfile
  friend class TIsamtempfile;
  // @cfriend TRecfield
  friend class TRecfield;
  //  friend class      TCursor;
  // friend TRecnotype  __buildcursor(TFilecursor* tic, TRecnotype rp);
  // friend TRecnotype  __filtercursor(TFilecursor* tic);
  // friend bool        __evalcondition(TBaseisamfile* i,TString& condition);
  // friend void        __readrec(TFilecursor* tic);
  
  // @access:(INTERNAL) Private Member
  
  // @cmember:(INTERNAL) Descrittore del file isam
  isdef* _isamfile;
  // @cmember:(INTERNAL) Numero logico del record corrente
  int _logicnum;
  // @cmember:(INTERNAL) Ultimo errore
  int _lasterr;
  // @cmember:(INTERNAL) Permette di sapere se rimuovere il record alla fine
  bool _delrec;
  // @cmember:(INTERNAL) Permette di sapere se rimuovere il record alla fine dalla lista interna di record
  bool _delopenrec;
  // @cmember:(INTERNAL) Puntatore a record corrente
  TRectype* _current;
  // @cmember:(INTERNAL) UNUSED
  TFile _hf;
  // @cmember:(INTERNAL) UNUSED
  TFile _hfhd;
  // @cmember:(INTERNAL) Indica se il file e' archivio storico
  bool _historicfile;
  // @cmember:(INTERNAL) UNUSED
  TRecnotype _lasthf;
  // @cmember:(INTERNAL) Record corrente
  TRecnotype _recno;
  // @cmember:(INTERNAL) Indica se il file possiede dei campi memo
  bool _has_memo;
  
  // @cmember:(INTERNAL) IO su file:
  int _next(word lockop = _nolock);
  int _read(TRectype& rec, word op = _isequal, word lockop = _nolock);
  int _readat(TRectype& rec, TRecnotype nrec, word lockop = _nolock);
  int _write(const TRectype& rec);
  int _rewrite(const TRectype& rec);
  int _remove(const TRectype& rec);
// @access Protected Member
protected:
  // @cmember Ritorna il descrittore del file isam
  isdef** ptrfilehnd() const
  { return (isdef**) &_isamfile;}
  // @cmember Assegna NULL al descrittore del file isam
  void clearfilehnd()
  { _isamfile = NULL;}
  
  // @cmember UNUSED
  void recover();
  // @cmember Apre il file isam di base con lock
  int _open(unsigned int mode = _manulock);
  // @cmember Chiude il file isam di base
  int _close();        

  // @cmember Ritorna il nome del file aperto
  const char* filename() const;

// @access Public Member
public:                                                 
  // @cmember Sostituisce il record corrente del del file
  void set_curr(TRectype * curr); 
  // @cmember Attiva la chiave <p nkey> sul file aperto
  void setkey(int nkey);
  // @cmember Ritorna la chiave attiva sul file aperto
  int getkey() const;
  // @cmember Setta la variabile <p _leaterr>
  void setstatus(int status) 
  { _lasterr = status; }
  // @cmember Si posiziona sul primo record del file (vedi <t TReclock>)
  virtual int first(word lockop = _nolock);
  // @cmember Si posiziona sull'ultimo record del file (vedi <t TReclock>)
  virtual int last(word lockop = _nolock);
  // @cmember Si posiziona sul successivo record del file (vedi <t TReclock>)
  virtual int next(word lockop = _nolock);
  // @cmember Si posiziona sul 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();
  // @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
  const char* description() const;
  // @cmember Ritorna il numero di record contenuti nel file corrente
  virtual TRecnotype eod() const ;

  // @cmember Ritorna l'handle del file isam nella tabella
  isdef* filehnd() const
  { return (isdef*) _isamfile;}

  // @cmember Numero di records presenti nel file
  long items() const;  // n.o di records nel file

#ifndef FOXPRO
  // @cmember Ritorna il contenuto del campo <p fieldname> di tipo int
  int get_int(const char* fieldname) const
  { return curr().get_int(fieldname);}
  // @cmember Ritorna il contenuto del campo <p fieldname> di tipo long
  long get_long(const char* fieldname) const 
  { return curr().get_long(fieldname);}
  // @cmember Ritorna il contenuto del campo <p fieldname> di tipo word
  word get_word(const char* fieldname) const 
  { return curr().get_word(fieldname);}
  // @cmember Ritorna il contenuto del campo <p fieldname> di tipo carattere
  char get_char(const char* fieldname) const 
  { return curr().get_char(fieldname);}
  // @cmember Ritorna il contenuto del campo <p fieldname> di tipo boolean
  bool get_bool(const char* fieldname) const 
  { return curr().get_bool(fieldname);}
  // @cmember Ritorna il contenuto del campo <p fieldname> di tipo real
  real get_real(const char* fieldname) const 
  { return curr().get_real(fieldname);}
  // @cmember Ritorna il contenuto del campo <p fieldname> di tipo memo (vedi <mf TRectype::get_memo>)
  bool get_memo(const char* fieldname, TTextfile& txt)
  { return curr().get_memo(fieldname, txt); }
#endif
  // @cmember Ritorna il contenuto del campo <p fieldname> di tipo data
  TDate get_date(const char* fieldname) const 
  { return curr().get_date(fieldname);}

#ifndef FOXPRO
  // @cmember Ritorna il contenuto del campo <p fieldname> (non tipizzata)
  const TString& get(const char* fieldname) const 
  { return curr().get(fieldname);}

  // @cmember Setta il contenuto del campo <p fieldname> di tipo int
  void put(const char* fieldname, int val)
  { curr().put(fieldname, val);}
  // @cmember Setta il contenuto del campo <p fieldname> di tipo long
  void put(const char* fieldname, long val)
  { curr().put(fieldname, val);}
  // @cmember Setta il contenuto del campo <p fieldname> di tipo word
  void put(const char* fieldname, word val)
  { curr().put(fieldname, val);}
  // @cmember Setta il contenuto del campo <p fieldname> di tipo data
  void put(const char* fieldname, const TDate& val)
  { curr().put(fieldname, val);}
  // @cmember Setta il contenuto del campo <p fieldname> di tipo carattere
  void put(const char* fieldname, char val)
  { curr().put(fieldname, val);}
  // @cmember Setta il contenuto del campo <p fieldname> di boolean
  void put(const char* fieldname, bool val)
  { curr().put(fieldname, val);}
  // @cmember Setta il contenuto del campo <p fieldname> di tipo real
  void put(const char* fieldname, const real& val)
  { curr().put(fieldname, val);}
  // @cmember Setta il contenuto del campo <p fieldname> di tipo memo (vedi <mf TRectype::put_memo>)
  void put(const char* fieldname, TTextfile& txt)
  { curr().put(fieldname, txt); }
#else  
  // @cmember Ritorna una stringa con il contenuto del campo <p fieldname>
  const char* get_str(const char* fieldname) const 
  { return (const char *) curr().get_str(fieldname);}
#endif     

#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
  void zero() 
  { curr().zero();}
  // @cmember Vuota tutto il record corrente usando il carattere <p c>
  void zero(char c) 
  { curr().zero(c);}
  // @cmember Riempie il campo <p fieldname> del record corrente di spazi
  void blank(const char * fieldname) 
  { curr().blank(fieldname); }
  // @cmember Setta il record corrente con il contenuto del record <p rec>
  TRectype& operator =(const TRectype& rec) 
  { return curr() = rec;}
  
  // @cmember Costruttore
  TBaseisamfile(int logicnum, bool linkrecinst = FALSE);
  // @cmember Distruttore
  virtual ~TBaseisamfile();
};

// @doc EXTERNAL

// @class TIsamfile | Classe per la definizione delle operazione sul file isam
//
// @base public | TBaseisamfile
class TIsamfile : public TBaseisamfile

// @author:(INTERNAL) Sandro
{

// @access Public Member
public:
  // @cmember Aggiorna i flags associati al file
  int flags(bool updateeod = FALSE);
  // @cmember Apre un file di isam con lock (vedi <mf TBaseisamfile::_open>)
  int open(unsigned int mode = _manulock) 
  { return _open(mode);} 
  // @cmember Chiude il file di isam
  int close() 
  { return _close();}
  // @cmember Costruttore
  TIsamfile(int logicnum, bool linkrecinst);
  // @cmember Distruttore
  virtual ~TIsamfile();
};

// @doc EXTERNAL

// @class TSystemisamfile | Classe per la definizione delle funzione per la creazione di un file
//          di isam
//
// @base public | TIsamfile
class TSystemisamfile : public TIsamfile

// @author:(INTERNAL) Sandro

{
// @access:(INTERNAL) Private Memebr

  // @cmember:(INTERNAL) Array di campi che descrivono il record del file
  TArray _flds;
  // @cmember:(INTERNAL) Array di espressione
  TArray _exps;

  // @cmember:(INTERNAL) Recupera le conversioni logiche da effettuare sul file
  bool getlcf(long flev);
  // @cmember:(INTERNAL) Esegue la conversione del file. Ritorna il codice di errore.
  int exec_convapp(long flev, const bool before);
  // @cmember:(INTERNAL) Esegue la conversione sui record del file (utilizzando le espressione definite
  //          in fconv.ini)
  void makelc(TRectype& rec);

// @access Public Member
public:
  // @cmember Costruisce un file isam di dimensione <p eox>
  int build(TRecnotype eox);
  // @cmember Estende un file preesistente alla dimensione <p eox>
  int extend(TRecnotype eox);
  // @cmember Calcola lo spazio che il file occuperebbe se venisse esteso a <p eox>
  long size(TRecnotype eox);
  // @cmember Esegue la conversione del tracciato record del file
  int update(const TTrec& newrec, bool vis = TRUE);
  
  // @cmember Esegue sia <mf TSystemisamfile::packfile> e <mf TSystemisamfile::packindex>
  int pack(bool vis = TRUE, bool ask = TRUE);
  // @cmember Rimuove fisicamente i record cancellati
  int packfile(bool vis = TRUE);
  // @cmember Rimuove fisicamente gli indici cancellati
  int packindex(bool vis = TRUE, bool ask = TRUE);

  // @cmember Importa un file ascii
  int load(const char* from, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool extended = FALSE) ;

  // @cmember Esporta VERSO un file ascii. 
  int dump(const char* to, int nkey = 1, char fs = '|', char fd = '\0', char rs = '\n', bool vis = TRUE, bool withdeleted = FALSE);

  // @cmember Costruttore
  TSystemisamfile(int logicnum, bool linkrecinst = FALSE): TIsamfile(logicnum, linkrecinst) 
  {}
  // @cmember Distruttore
  virtual ~TSystemisamfile() 
  {}
};

// @doc EXTERNAL

// @class TLocalisamfile | Classe per la definizione di un isam file
//
// @base public | TBaseisamfile
class TLocalisamfile : public TBaseisamfile

// @author:(INTERNAL) Sandro
{
// @access:(INTERNAL) Private Member

  // @cmember:(INTERNAL) Indica se il file e' stato aperto come Localisamfile
  bool _was_open;
  // @cmember:(INTERNAL) Vecchia chiave se il file e' gia' aperto
  int _oldkey;

// @access Protected Member
protected:
  // @cmember Apre il file con lock (vedi <mf TBaseisamfile::_open>)
  int open(unsigned int mode = _manulock);
  // @cmember Chiude il file aperto
  int close() ;

// @access Public Member
public:
  // @cmember Avanza di <p npos> record
  virtual int operator +=(const TRecnotype npos);
  // @cmember Sposta indietro di <p npos> record
  virtual int operator -=(const TRecnotype npos);
  // @cmember Avanza al record successivo
  virtual int operator ++();
  // @cmember Indietreggia al record precedente
  virtual int operator --();
  // @cmember Ritorna TRUE se tabella
  virtual bool tab() const 
  { return FALSE;}

  // @cmember Costruttore. <p Linkrecinst> dice se il file deve utilizzare un area record 
  //        separata oppure la stessa.
  TLocalisamfile(int logicnum, bool linkrecinst = FALSE);
  // @cmember Distruttore
  virtual ~TLocalisamfile();
};


// @doc EXTERNAL

// @class TIsamtempfile | Classe per la definizione del file isam temporaneo
//
// @base public | TLocalisamfile
class TIsamtempfile : public TLocalisamfile

// @author:(INTERNAL) Sandro
{                  

// @access:(INTERNAL) Private Member

  //@cmember:(INTERNAL) Indica se cancellare il file in chiusura        
  bool _autodel; 

// @access Protected Member  
protected:
  // @cmember Apre il file
  int open(const char* radix, bool create, TRecnotype eod, TRecnotype eox);
  // @cmember Chiude il file
  int close(); 

// @access Public Member
public:                
  // @cmember Setta il valore di <p _autodel> a <p val>
  void set_autodel(bool val=TRUE) 
  {_autodel = val;}
  // @cmember Costruttore
  TIsamtempfile(int logicnum, const char* radix, bool create);
  // @cmember Distruttore
  virtual ~TIsamtempfile();
};

// @doc EXTERNAL

// @class TRec_array | Classe per la definizione un array di record
//
// @base public | TArray
class TRec_array : public TArray

// @author:(INTERNAL) Sandro
{
// @access Public Member
public:
  // @cmember Costruttore.
  TRec_array(int dimension, TBaseisamfile& i);
};

// @class TRecfield | Classe per la gestione dei campi di un record
//
// @base public | TObject
class TRecfield : public TObject

// @author:(INTERNAL) Guido

// @access:(INTERNAL) Private Member
{
  // @cmember:(INTERNAL) Nome del campo
  char _name[12];
  // @cmember:(INTERNAL) Puntatore a inizio record
  TRectype* _rec;
  // @cmember:(INTERNAL) Puntatore a inizio campo
  char* _p;
  // @cmember:(INTERNAL) Lunghezza del campo
  byte _len;
  // @cmember:(INTERNAL) Numero di decimali del campo
  byte _dec;
  // @cmember:(INTERNAL) Tipo del campo 
  TFieldtypes _type;

  // @cmember:(INTERNAL) Setta il campo <p to>-esimo con i valori di <p from>-esimo
  void set(int from, int to);

// @access Public Member
public:
  // @cmember Operatore di assegnamento per tipo intero
  int operator =(int i) ;
  // @cmember Operatore di assegnamento per tipo long
  long operator =(long l) ;
  // @cmember Operatore di assegnamento per tipo data
  const TDate& operator =(const TDate& d) ;
  // @cmember Operatore di assegnamento per tipo carattere
  const char* operator =(const char* s) ;
#ifndef FOXPRO
  // @cmember Operatore di assegnamento per tipo real
  const real& operator =(const real& r) ;
#endif

  // @cmember Operatore di estrazione per tipo intero
  operator int() const ;
  // @cmember Operatore di estrazione per tipo long
  operator long() const ;
  // @cmember const char * | operator const char* | | Operatore di estrazione per tipo carattere
  operator const char*() const ;
  // @cmember Operatore di estrazione per data
  operator TDate() const ;
#ifndef FOXPRO
  // @cmember const real | operator const real | | Operatore di estrazione per real
  operator const real() const ;
#endif

  // @cmember Scrive un campo packed. Sarebbe meglio non usare mai campi packed.
  void setptr(TRecnotype r);
  // @cmember Legge un campo packed. Sarebbe meglio non usare mai campi packed.
  TRecnotype ptr() const;

  // @cmember Ritorna un puntatore all'inizio del campo nel record. Dovrebbe essere protected!
  const char* pos() const 
  { return (const char*) _p;}
  // @cmember Ritorna la lunghezza del campo
  int len() const 
  { return (int) _len;}
  // @cmember Ritorna il numero di decimali del campo
  int dec() const { return (int) _dec;} 
  TFieldtypes type() const 
  // @cmember Ritorna il tipo del campo
  { return (TFieldtypes) _type;}
  // @cmember Ritorna il puntatore a inizio record
  TRectype& record() const 
  { return *_rec;}

  // @cmember Costruttore
  TRecfield(TRectype& rec, const char* name, int from = 0, int to = -1);
};

/*

   class TTransaction
   {
   public:
   // @FPUB
   void begin();
   void end(bool success = TRUE);
   void abort() { end(FALSE);}
   };

   */

#ifdef __ISAM_CPP
#define extern
#endif

extern TRectype** openrec;
extern void get_idx_names(int logicnum, TToken_string& i_names); 

#undef extern

void set_autoload_new_files(bool on);

#endif // __ISAM_