root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Aggiunta documentazione in linea.

Browse Source 
git-svn-id: svn://10.65.10.50/trunk@2280 c028cbd2-c16b-5b4b-a496-9718f37d4682
This commit is contained in:
andrea 1995-12-12 17:47:56 +00:00
parent 82fccf970c
commit 6b0ab4cb09
3 changed files with 702 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
include/isam.cpp
View File

@ -60,13 +60,21 @@ HIDDEN void UNKNOWN_FIELD(int num, const char* name)
HIDDEN bool __autoload = TRUE;
// @doc EXTERNAL
////////////////////////////////////////////////////////////////////////////////////////////////////
// Funzioni implementate per la gestione file dati tramite Codebase
////////////////////////////////////////////////////////////////////////////////////////////////////
// Inizio(@)
void get_idx_names(int logicnum, TToken_string& i_names) // Returns a Token_string with the index names. (Current prefix!)
// @func Ritorna una Token_string con in nome dell'indice
void get_idx_names(
int logicnum, // @parm Numero logico del file di cui riconoscere l'indice
TToken_string& i_names) // @parm Token_string in cui inserire il nome dell'indice
// @comm Ritorna il nome con il prefisso corrente
{
long c = DB_getconf();
TDir d;
@ -374,8 +382,12 @@ HIDDEN int delkeys(isfdptr fd, char* record,long recno)
////////////////////////////////////////////////////////////////////////////////////////////////////
// Fine(@)
// @func Setta il valore della variabile <p __autoload>
void set_autoload_new_files(
bool on) // @parm Valore da assegnare
// @comm Il valore di <p __autoload> indica il caricamento dei valori standard dei file
void set_autoload_new_files(bool on)
{
__autoload = on;
}
@ -1172,8 +1184,18 @@ void TBaseisamfile::indexoff()
}
// @mfunc Apre il file isam di base con lock
//
// @rdesc Ritorna NOERR se e' riuscita ad aprire il file, altrimenti ritorna il numero di errore
// generato (vedi <e TIsamerr>).
int TBaseisamfile::_open(
unsigned int mode) // @parm Indica il modo di apertura del file (default _manulock)
int TBaseisamfile::_open(unsigned int mode)
// @comm Il parametro <p mode> puo' assumere i valori:
//
// @flag _manulock | Il lock dei record viene fatto manualmente
// @flag _exclock | Il file viene aperte in modo esclusivo
// @flag _autolock | Il lock dei record viene fatto in modo automatico
{
CHECKS(filehnd() == NULL, "File already open ", (const char*)filename());
@ -1401,7 +1423,12 @@ TIsamfile::~TIsamfile()
}
int TIsamfile::flags(bool updateeod)
// @cmember Aggiorna i flags associati al file
//
// @rdesc Ritorna NOERR se e' riuscita ad eseguiore l'operazione, altrimenti ritorna il numero
// di errore generato (vedi <e TIsamerr>).
int TIsamfile::flags(
bool updateeod) // @parm Indica se aggiornare anche l'EOD del file
{
TDir d;
@ -1488,8 +1515,18 @@ TIsamtempfile::~TIsamtempfile()
close();
}
// @mfunc Apre il file
//
// @rdesc Ritorna NOERR se e' riuscita ad aprire il file, altrimenti ritorna il numero di errore
// generato (vedi <e TIsamerr>).
int TIsamtempfile::open(
const char* radix, // @parm Radice del path del file
bool create, // @parm Indica se va creatoun nuovo file (se FALSE il file esiste gia')
TRecnotype eod, // @parm Numero di record presenti nel file
TRecnotype eox) // @parm Numero di record da aggiungere al file
int TIsamtempfile::open(const char* radix, bool create, TRecnotype eod, TRecnotype eox)
// @comm Nel case <p create> sia TRUE allora viene settato automaticamente il valore di <p _autodel>
// a TRUE, cioe' viene abilitata l'eliminazione del file in chiusura.
{
int err = NOERR;
@ -1664,7 +1701,15 @@ long TSystemisamfile::size(TRecnotype eox)
}
#ifndef FOXPRO
bool TSystemisamfile::exec_convapp(long flev, const bool before)
// @mfunc Esegue la conversione del file
//
// @rdesc Ritorna il rusultato dell'operazione
//
// @flag TRUE | Se la conversione e' stata effettuata correttamente
// @flag FALSE | Se è stato rilevato un errore durante la conversione (viene emesso un <f error_box>)
bool TSystemisamfile::exec_convapp(
long flev, // @parm Livello a cui aggiornare l'archivio
const bool before) // @parm SANDRO???
{
const char * const v = before ? "BCNV" : "ACNV";
@ -1747,13 +1792,19 @@ void TSystemisamfile::makelc(TRectype& rec)
}
}
int TSystemisamfile::update(TTrec& newrec, bool vis)
// @mfunc Esegue la conversione del tracciato record del file
//
// @rdesc Ritorna il risulato della conversione, altrimenti il codice di errore generato
// (vedi <e TIsamerr>)
int TSystemisamfile::update(
TTrec& newrec, // @parm Nuovo tracciato record con cui aggiornare il file
bool vis) // @parm Indica se visualizzare lo stato dell'operazione
{
CHECKS(filehnd() == NULL, "Can't update open file", (const char*)filename());
CHECK(newrec.len() != 0, "Can't update to file with empty field info");
TDir dir;
TDir dir;
dir.get(num(), _unlock, _nordir, _sysdirop);
const bool is_com = prefix().is_com();
@ -1887,8 +1938,14 @@ int TSystemisamfile::update(TTrec& newrec, bool vis)
return err;
}
// @mfunc Rimuove fisicamente i record cancellati
//
// @rdesc Ritorna NOERR se l'operazione di compattamento e' riuscita, altrimenti il codice di
// di errore generato (vedi <e TIsamerr>).
int TSystemisamfile::packfile(
bool vis) // @parm Indica se visualizzare lo stato dell'operazione
int TSystemisamfile::packfile(bool vis)
// @xref <mf TSystemisamfile::packindex>
{
int err=NOERR;
@ -1906,8 +1963,14 @@ int TSystemisamfile::packfile(bool vis)
return err;
}
// @mfunc Rimuove fisicamente gli indici cancellati
//
// @rdesc Ritorna NOERR se l'operazione di compattamento e' riuscita, altrimenti il codice di
// di errore generato (vedi <e TIsamerr>).
int TSystemisamfile::packindex(
bool vis) // @parm Indica se visualizzare lo stato dell'operazione
int TSystemisamfile::packindex(bool vis)
// @xref <mf TSystemisamfile::packfile>
{
int err=NOERR;
@ -1944,7 +2007,19 @@ int TSystemisamfile::pack(bool vis)
return err;
}
int TSystemisamfile::load(const char* from, char fs, char fd, char rs, bool vis, bool extended)
// @mfunc Importa un file ascii
//
// @rdesc Ritorna NOERR se l'operazione di lettura e' riuscita, altrimenti il codice di
// di errore generato (vedi <e TIsamerr>).
int TSystemisamfile::load(
const char* from, // @parm Nome del file da importare
char fs, // @parm Carattere separatore di campo (default <pipe>)
char fd, // @parm Carattere delimitatore di campi (default '\\0')
char rs, // @parm Carattere separatore di record (default '\\n')
bool vis, // @parm Indica se visualizzare lo stato dell'operazione (default TRUE)
bool extended) // @parm SANDRO???(default FALSE)
// @xref <mf TSystemisamfile::dump>
{
FILE* fl = fopen(from, "r");
@ -2121,7 +2196,20 @@ int TSystemisamfile::load(const char* from, char fs, char fd, char rs, bool vis,
return err;
}
int TSystemisamfile::dump(const char* to, int nkey, char fs, char fd, char rs, bool vis, bool withdeleted)
// @mfunc Esporta VERSO un file ascii.
//
// @rdesc Ritorna NOERR se l'operazione di esportazione e' riuscita, altrimenti il codice di
// di errore generato (vedi <e TIsamerr>).
int TSystemisamfile::dump(
const char* to, // @parm Nome del file verso quale esportare
int nkey, // @parm Numero della chiave di ordinamento con cui scaricare i dati (defualt 1)
char fs, // @parm Carattere seperatore di campo (defualt <pipe>)
char fd, // @parm Carattere delimitatore di campo (default '\\0')
char rs, // @parm Carattere separatore di record (default '\\n')
bool vis, // @parm Indica se visualizzare lo stato dell'operazione (defualt TRUE)
bool withdeleted) // @parm Indica se scaricare anche i record cancellati (dafault FALSE)
// @xref <mf TSystemisamfile::load>
{
FILE* f = fopen(to, "w");
@ -2353,7 +2441,18 @@ const char* TRectype::last_key_field(int key) const
return rf.Name;
}
int TRectype::compare_key(const TRectype& rec, int key, int skip_last) const
// @mfunc Confronta le chiavi di due record
//
// @rdesc Ritorna il risultato di una <f strcmp>:
//
// @flag 0 | Se le due chiavi sono uguali
// @flag <lt><gt>0 | Se le due chiavi sono diverse
int TRectype::compare_key(
const TRectype& rec, // @parm Record di cui confrontare le chiavi
int key, // @parm Numero della chiave del presente record (defautl 1)
int skip_last) const // @parm Numero di campi di ignorare nella comparazione a partire dall'ultimo
// @xref <mf TRectype::build_key>
{
TString256 key1= build_key(key);
TString256 key2 = rec.build_key(key);
@ -2589,7 +2688,12 @@ bool TRectype::get_bool(const char* fieldname) const
}
bool TRectype::get_memo(const char* fieldname, TTextfile& txt) const
// @mfunc Ritorna il contenuto di un campo memo
//
// @rdesc Ritorna sempre TRUE
bool TRectype::get_memo(
const char* fieldname, // @parm Nome del campo da cui estrarre il contenuto
TTextfile& txt) const // @parm Reference della variabile a cui assegnare il contenuto dell campo
{
TToken_string memo( get( fieldname ), '\n' );
int last = memo.items( );

712
include/isam.h
View File

File diff suppressed because it is too large Load Diff

101
include/rectypes.h
View File

@ -9,28 +9,85 @@
typedef long TRecnotype;
// @END
enum TFilelock { _excllock = 0x100, _autolock = 0x200,
_manulock = 0x400};
enum TReclock { _unlock = 0x1000, _nolock = 0x2000, _lock = 0x4000,
_testandlock = (int)0x8000} ;
enum TDirtype { _nordir, _comdir } ;
enum TDirop { _nordirop, _sysdirop };
enum TFieldtypes { _nullfld, _alfafld, _intfld, _longfld, _realfld,
_datefld, _wordfld, _charfld, _boolfld , _intzerofld, _longzerofld,
_memofld} ;
enum TIsamop { _isfirst = 0x0, _islast = 0x1, _isnext= 0x2,
_isprev = 0x4, _iscurr = 0x8, _isequal = 0x10,
_isgreat = 0x20, _isgteq = 0x40, _isnextn = 0x100,
_isprevn = 0x200} ;
enum TIsamerr { _iseof = 201, _isbof = 202, _isfileovf = 203,
_iskeynotfound = 204, _isemptyfile = 205,
_isdupkey = 206, _isnocurkey = 207,
_iskeyrangeerr = 211, _iskeyerr = 212,
_iskeylenerr = 214, _ispatherr = 216, _ispathfull = 217,
_isnrecerr = 218, _isfilefull = 219, _isnotopen = 220,
_isnotcurr = 221, _isalropen = 222, _isdeadlock = 223,
_isreinsert = 224, _islocked = 225} ;
typedef long TRecnotype;
// @doc EXTERNAL
// @enum TFilelock | Comandi per l'apertura dei file
enum TFilelock {
_excllock = 0x100, // @emem Apertura in modo esclusivo
_autolock = 0x200, // @emem Apertura del file in modo auto
_manulock = 0x400}; // @emem Apertura del file in modo manuale
// @enum TReclock | Comandi per la gestione dei lock su record
enum TReclock {
_unlock = 0x1000, // @emem Sblocca il record
_nolock = 0x2000, // @emem Nessuna operazione di lock
_lock = 0x4000, // @emem Blocca il record
_testandlock = (int)0x8000} ; // @emem Blocca il record se possibile, altrimenti ritorna errore
// @enum TDirtype | Comandi per la gestione di <c TDir>
enum TDirtype {
_nordir, // @emem Riferimento operazioni col prefix corrente
_comdir } ; // @emem Riferimento operazioni al direttorio comune
// @enum TDirop | Comandi per la gestione di <c TDir>
enum TDirop {
_nordirop, // @emem Riferimento per operazioni normali
_sysdirop }; // @emem Riferimento per operazioni di sistema
// @enum TFieldtypes | Elenco tipi di campi
enum TFieldtypes {
_nullfld, // @emem Campo vuoto
_alfafld, // @emem Campo di tipo alfanumerico
_intfld, // @emem Campo di tipo intero
_longfld, // @emem Campo di tipo intero lungo
_realfld, // @emem Campo di tipo reale (vedi <c real>)
_datefld, // @emem Campo di tipo data (vedi <c TDate>)
_wordfld, // @emem Campo di tipo intero senza segno
_charfld, // @emem Campo di tipo carattere
_boolfld , // @emem Campo di tipo booleano
_intzerofld, // @emem Campo di tipo intero zero filled
_longzerofld, // @emem Campo di tipo intero lungo zero filled
_memofld} ; // @emem Campo di tipo memo
// @enum TIsamop | Comandi per eseguire operazioni di lettura sul file
enum TIsamop {
_isfirst = 0x0, // @emem Legge il primo record del file
_islast = 0x1, // @emem Legge l'ultimo record del file
_isnext= 0x2, // @emem Legge il prossimo record del file
_isprev = 0x4, // @emem Legge il precedente record del file
_iscurr = 0x8, // @emem Legge il record corrente del file (rilettura)
_isequal = 0x10, // @emem Legge il record con chiave uguale a quella specificata
_isgreat = 0x20, // @emem Legge il record con chiave maggiore di quella specificata
_isgteq = 0x40, // @emem Legge il record con chiave maggiore o uguale di quella specificata
_isnextn = 0x100, // @emem Legge i prossimi n record
_isprevn = 0x200} ; // @emem Legge i precedenti n record
// @enum TIsamerr | Elenco codici di errore
enum TIsamerr {
_iseof = 201, // @emem End of file
_isbof = 202, // @emem Begin of file
_isfileovf = 203, // @emem Overflow del file
_iskeynotfound = 204, // @emem Chiave non trovata
_isemptyfile = 205, // @emem File vuoto
_isdupkey = 206, // @emem Chiave duplicata
_isnocurkey = 207, // @emem Non esiste la chiave corrente
_iskeyrangeerr = 211, // @emem Valore errato della chiave
_iskeyerr = 212, // @emem Errore generico della chiave
_iskeylenerr = 214, // @emem Lunghezza della chiave errata
_ispatherr = 216, // @emem File indice non coerente
_ispathfull = 217, // @emem UNUSED
_isnrecerr = 218, // @emem Errore sul numero dei record
_isfilefull = 219, // @emem File o disco pieno
_isnotopen = 220, // @emem File non aperto
_isnotcurr = 221, // @emem Non esiste il record corrente
_isalropen = 222, // @emem File gia' aperto
_isdeadlock = 223, // @emem Condizione di deadlock
_isreinsert = 224, // @emem Chiva duplicata su indici diversi da 1
_islocked = 225} ; // @emem Record bloccato
typedef long TRecnotype;
#endif // __RECTYPES_H