#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;
class TRectype;

// @doc EXTERNAL

// @class TMemo_info | Classe per la definizione dei campi Memo
//
// @base public | TObject
class TMemo_info : public TObject
// @author(:INTERNAL) Sandro
{
// @access Private Member

  // @cmember Campi memo modificati
  TBit_array _dirty;
  // @cmember Array di stringhe contenteti i campi memo
  TString_array _data;
  // @cmember Numero di record sul file dati
  TRecnotype _recno;
  // @cmember Record che possiede il campo memo
  const TRectype  * _owner;   

// @access Protected Member
protected:

  // @cmember Ritorna il descrittore del record (vedi <t RecDes>)
  RecDes * rec_des( ) const;
  
// @access Public Member
public:
  // @cmember Ritorna il numero di record sul file dati
  TRecnotype recno( ) const
  { return _recno; }

  // @cmember Ritorna il numero logico del record
  int num() const ;
  // @cmember Setta il numero di record sul file dati
  void recno( TRecnotype r )
  { _recno = r; }
  // @cmember Setta il contenturo del campo memo <p fieldname> con <p data>
  void put( const char * fieldname, const char * data );
  // @cmember Ritorna il contenturo del campo memo <p fieldname> con <p data>
  TString& get( const char * fieldname );
  // @cmember Scrive fisicamente il campo memo sul file
  void write_data( isdef * def );
  // @cmember Ritorna TRUE se il campo memo <p fieldname> e' stato letto dal file
  bool memo_loaded( const char * fieldname );
  // @cmember Annula tuttle le modifiche sui campi memo (prima della scrittura sul file)
  void reset( );

  // @cmember Costruttore
  TMemo_info( const TRectype * owner, const TRecnotype recno );
  // @cmember Costruttore
  TMemo_info( const TRectype * owner, TMemo_info& memoinfo);
  // @cmember Distruttore
  virtual ~TMemo_info( );
};


// @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 TIsamtemp file
  friend class TIsamtempfile;

// @access Private Member

  // @cmember Puntatore all'inizio inizio del record
  char* _rec;
  // @cmember Numero logico del record
  int _logicnum;
  // @cmember Lunghezza del record
  int _length;
  // @cmember Indica se il record e' vuoto
  bool _isempty;
  // @cmember Indentificatore della tabella
  char _tab[5];
  // @cmember Campo "COD" della tabella 
  TRecfield * _cod;
  // @cmember Puntatore alla classe contenente i campi memo
  TMemo_info * _memoinfo;

// @access Protected Member
protected:  // TObject
  // @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;

protected:
  // @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;}

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

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

// @access Public Member
public:
  // @cmember Ritorna il numero di campi del record
  int items() const;
  // @cmember Setta il record come non suoto (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' satto 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>
  TFieldtypes type(const char* fieldname) const;
  // @cmember Ritorna la lunghezza del campo <p fieldname>
  int length(const char* fieldname) const;
  // @cmember Ritorna numero di decimali del campo <p fieldname>
  int ndec(const char* fieldname) const;
  // @cmember Indica se esiste il campo <p fieldname>
  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 contenuto del campo <p fieldname> (non tipizzata)
  const char* get_str(const char* fieldname) const ;
#ifndef FOXPRO
  // @cmember Riotna 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 long
  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);
#endif

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

  // @cmember Vuota il campo puntato da <p fieldname>
  void zero(const char * fieldname);
  // @cmember Vuota tutto il record
  void zero();
  // @cmember Vuota tutto il record usando il carattere <p c>
  void zero(char c);

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

  // @cmember Assegnazione tra TRectype
  TRectype& operator =(const TRectype& rec);
  // @cmember Assegnazione tra TRectype
  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; }

  // @cmember Costruttore Costruisce un record staccato da un file.
  //          Sarebbe meglio utilizzare una delle altre due
  TRectype(int logicnum);
  // @cmember Costruttore. Costruisce 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();
  
  // @cmember Inizializza la struttura di <c TMemo_info>
  void init_memo_info(const TRecnotype recnum );
  // @cmember Ritora il refernce alla <c TMemo_info>
  TMemo_info& memo_info( ) const 
  { CHECK( _memoinfo, "Tentativo di accesso ad una memoinfo vuota!" ); return *_memoinfo; }
  // @cmember Scrive le iunformazioni contenute in <c TMemo_info>
  void write_memo_info( isdef * def ) const;
  // @cmember Indica se il record possiede un campo memo
  bool has_memo() const 
  { return _memoinfo != NULL; }

  
};


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

// @author(:INTERNAL) Sandro

// @access Provate Member
{
  // @cmember Descrittore del file isam
  isdef* _isamfile;
  // @cmember Numero logico del record corrente
  int _logicnum;
  // @cmember Ultimo errore
  int _lasterr;
  // @cmember Permette di sapere se rimuovere il record alla fine
  bool _delrec;
  // @cmember Permette di sapere se rimuovere il record alla fine dalla lista interna di record
  bool _delopenrec;
  // @cmember Puntatore a record corrente
  TRectype* _current;
  // @cmember UNUSED
  TFile _hf;
  // @cmember UNUSED
  TFile _hfhd;
  // @cmember Indica se il file e' archivio storico
  bool _historicfile;
  // @cmember UNUSED
  TRecnotype _lasthf;
  // @cmember Record corrente
  TRecnotype _recno;
  // @cmember Indica se il file possiede dei campi memo
  bool _has_memo;
  
  // @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);

  // @cmember UNUSED
  int gethr(TRectype& rec, TDate& atdate);
  // @cmember Ritorna NOERR
  int addhr(const TRectype& rec, TDate& atdate);
  // @cmember Ritorna NOERR
  int rewhr(const TRectype& rec, TDate& atdate);
  // @cmember Ritorna NOERR
  int delhr(const TRectype& rec, TDate& atdate);

// access Protected Member
protected:
  // @cmember Ritorna il descrittore del file isam
  isdef** ptrfilehnd() const
  { return (isdef**) &_isamfile;}
  // @cmember Assegna NULL al descrittore del file isam
  void clearfilehnd()
  { _isamfile = NULL;}
  
  // @cmember UNUSED
  void recover();
  // @cmember Apre il file isam di base con lock
  int _open(unsigned int mode = _manulock);
  // @cmember Chiude il file isam di base
  int _close();        

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

// @access Public Member
public:
  // @cmember 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 variabiel <p _leaterr>
  void setstatus(int status) 
  { _lasterr = status; }
  // @cmember Si posiziona sul primo record del file (vedi <e TReclock>)
  virtual int first(word lockop = _nolock);
  // @cmember Si posiziona sull'ultimo record del file (vedi <e TReclock>)
  virtual int last(word lockop = _nolock);
  // @cmember Si posiziona sul successivo record del file (vedi <e TReclock>)
  virtual int next(word lockop = _nolock);
  // @cmember Si posiziona sul successivo record del file (UNUSED)
  virtual int next(TDate& atdate);
  // @cmember Si posiziona sul precedente record del file (vedi <e TReclock>)
  virtual int prev(word lockop = _nolock);
  // @cmember Si posiziona sul precedente record del file (UNUSED)
  virtual int prev(TDate& atdate);
  // @cmember Rilegge l'ultimo record letto (vedi <e TReclock>)
  virtual int reread(word lockop = _nolock, TDate& atdate = (TDate&)botime);
  // @cmember Rilegge l'ultimo record letto e lo copia in <p rec> (vedi <e TReclock>)
  virtual int reread(TRectype& rec, word lockop = _nolock, TDate& atdate = (TDate&)botime);
  // @cmember Salta <p nrec> record dalla posizione corrente (vedi <e TReclock>)
  virtual int skip(TRecnotype nrec, word lockop = _nolock);
  // @cmember Legge il record (vedi <e TReclock> e <e TIsamop>)
  virtual int read(word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime);
  // @cmember Legge il record e lo copia in <p rec> (vedi <e TReclock> e <e TIsamop>)
  virtual int read(TRectype& rec, word op = _isequal, word lockop = _nolock, TDate& atdate = (TDate&)botime);
  // @cmember Legge il record alla posizione  <p nrec> (vedi <e TReclock>)
  virtual int readat(TRecnotype nrec, word lockop = _nolock);
  // @cmember Legge il record alla posizione <p nrec> e lo copia in <p rec> (vedi <e TReclock>)
  virtual int readat(TRectype& rec, TRecnotype nrec, word lockop = _nolock);
  // @cmember Aggiunge un record
  virtual int write(TDate& atdate = (TDate&)botime);
  // @cmember Aggiunge un record copiando da <p rec>
  virtual int write(const TRectype& rec, TDate& atdate = (TDate&)botime);
  // @cmember Riscrive un record
  virtual int rewrite(TDate& atdate = (TDate&)botime);
  // @cmember Riscrive un record (il record <p rec>)
  virtual int rewrite(const TRectype& rec, TDate& atdate = (TDate&)botime);
  // @cmember Riscrive un record alla posizione <p nrec>
  virtual int rewriteat(TRecnotype nrec);
  // @cmember Riscrive un record alla posizione <p nrec> copiando da <p rec>
  virtual int rewriteat(const TRectype& rec, TRecnotype nrec);
  // @cmember Elimina il record
  virtual int remove(TDate& atdate = (TDate&)botime);
  // @cmember Elimina il record copiando da <p rec>
  virtual int remove(const TRectype& rec, TDate& atdate = (TDate&)botime);
  // @cmember Ritorna il numero logico del file sotto forma di stringa
  virtual const char* name() const;

  // @cmember Ritorna il record corrente
  TRecnotype recno() const 
  { return _recno;}
  // @cmember Attiva lock di tutto il file
  int lock(); 
  // @cmember Disattiva lock di tutto il file
  int unlock();
  // @cmember Accende gli indici
  void indexon();
  // @cmember Spegne gli indici
  void indexoff();
  // @cmember Ritorna il valore della varaibile <p _lasterr>
  int status() const 
  { return _lasterr; }
  // @cmember Controlla se il file e' valido (ritorna 0 se il file e' valido)
  int is_valid();
  // @cmember Ritorna il puntatore al record corrente
  TRectype& curr() const 
  {return *_current;}
  // @cmember Controlla se e' stata raggiunta la fine del file (TRUE se EOF)
  bool eof() const 
  { return status() == _iseof || status() == _isemptyfile;}
  // @cmember Controlla se e' stata raggiunta l'inizio del file (TRUE se BOF)
  bool bof() const 
  { return status() == _isbof || status() == _isemptyfile;}
  // @cmember Controlla se l'ultima operazione sul file e' stata effettuata correttamente 
  //        (TRUE se <p _lasterr> non contiene codici di errore)
  bool good() const 
  { return status() == NOERR;}
  // @cmember Controlla se l'ultima operazione sul file ha generato un errore
  //        (TRUE se <p _lasterr> contiene codici di errore)
  bool bad() const 
  { return status() != NOERR;}
  // @cmember Controlla se il file e' vuoto (TRUE se vuoto)
  bool empty();
  // @cmember Ritorna il numero logico del record corrente
  int num() const 
  { return _logicnum;}
  // @cmember Ritorna la descrizione del file corrente
  const char* description() const;
  // @cmember Ritorna il numero di record contenuti nel file corrente
  TRecnotype eod() const ;

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

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

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

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

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

  // @cmember Setta il contenuto del campo <p filedname> (non tipizzata)
  void put(const char* fieldname, const char* val)
  { curr().put(fieldname, val);}

  // @cmember Vuota il contenuto del campo <p fielname> nel recortd corrente (vedi <mf TRectype::zero>)
  void zero(const char * fieldname) 
  { curr().zero(fieldname);}
  // @cmember Vuota il contenturo 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 Controlla se il file possiede dei campi memo
  bool has_memo( );

  // @cmember Costruttore
  TBaseisamfile(int logicnum, bool linkrecinst = FALSE);
  // @cmember Distruttore
  virtual ~TBaseisamfile();
};

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

// @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 Private Memebr

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

  // @cmember Ritorna TRUE se la versione dell'archivio e' <lt>= di <p flev>
  bool getlcf(long flev);
  // @cmember Esegue la conversione del file
  bool exec_convapp(long flev, const bool before);
  // @cmember SANDRO???
  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(TTrec& newrec, bool vis = TRUE);
  
  // @cmember Esegue sia <mf TSystemisamfile::packfile> e <mf TSystemisamfile::packindex>
  int pack(bool vis = TRUE);
  // @cmember Rimuove fisicamente i record cancellati
  int packfile(bool vis = TRUE);
  // @cmember Rimuove fisicamente gli indici cancellati
  int packindex(bool vis = 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() 
  {}
};

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

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

  // @cmember Indica se il file e' stato aperto come Localisamfile
  bool _was_open;
  // @cmember 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 Spast 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();
};


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

// @author(:INTERNAL) Sandro
{                  

// @access Private Member

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


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

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

  // @cmember 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 Operatore di estrazione per tipo carattere
  operator const char*() const ;
  // @cmember Operatore di estrazione per data
  operator TDate() const ;
#ifndef FOXPRO
  // @cmember 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_
