campo-sirio/ab/ablib01.cpp

#include "ablib01.h"

#define MAX_ID_REL 999999999
#define NODO_AGGIUNTO "A"
#define NODO_MODIFICATO "M"
#define NODO_RIMOSSO "R"


/**************************************************************************************************/
//  TAnalisi_bil
/**************************************************************************************************/
TAnalisi_bil::TAnalisi_bil()
             :TRectype(LF_ANALISI)
{
  _voci   = new TLocalisamfile(LF_VOCI);
  _analisi= new TLocalisamfile(LF_ANALISI);
  _relaz  = NULL;
  _ana    = NULL;
  _inter_tree = new TInsert_albero();
  _newrec = new TRectype(LF_RELANA);
}


TAnalisi_bil::~TAnalisi_bil() 
{
  delete _inter_tree ;
  delete _voci;
  delete _ana;
  delete _relaz;
  delete _analisi;
  delete _newrec;
}

//Estraggo un nodo: in ingresso ho un id e il codice della tabella;
//in output ho il record e le informazioni per sapere cosa fare di quel record
TRectype TInsert_albero::extract_node(const TString &codtab,TRelana_id &id, TString &status)
{ 
  TToken_string key = codtab;
  TRectype rec(LF_RELANA);
  THash_object *row_status;
  
  if (id == ID_NULLO)
  { //Gestione interna
    _status_node.restart();
    row_status = _status_node.get_hashobj();
    status = (TString&)row_status->obj();
    id = (TRelana_id)row_status->key();
  }
  else
  {
    status = *(TString*)_status_node.objptr(id.string());
  }
  
  //Posso accedere alla cache (con la get) solo se il nodo non
  //è stato rimosso: se il nodo è stato rimosso, non sarà presente
  //nella cache, e quindi la get di un nodo che non esiste è un record
  //vuoto; questo record vuoto causerà errori nel momento in cui chiamerò
  //la flush per il distruttore; devo quindi evitare questo 
  //caso l'utilizzo della get
  if (status != NODO_RIMOSSO)  
  {
    key.add(id.string()); //La chiave è completamente ricostruita per la ricerca sulla cache
    rec = _ana_cache->get(key); //passo la chiave (formata da codtab e id) e ritorna il rectype
  }
  else
  { //Riempio manualmente il record che deve essere rimosso: inserisco solo la chiave
    rec.put(ABRA_CODAN,codtab);
    rec.put(ABRA_ID,id.string());
  }
  //A questo punto il record è completo e so già quale operazione devo compierci sopra
  
  //Questa parte serve per gestire l'assoc_array degli status
  if ((rec.empty()) && (status != NODO_RIMOSSO))
  { //Chiave non trovata: la chiave ricercata non è presente nella cache
    fatal_box("Errore nella lettura della cache o nella costruzione del record.");
  }
  _status_node.remove(id.string());
  return rec; //Ritorno un Trectype e passo la stauts node
}

int TAnalisi_bil::write(TBaseisamfile &analisi) const
{                      
  TLocalisamfile relana(LF_RELANA);
  int err = commit_body(relana);
  if (err)
    CHECK (FALSE,"Errore di scrittura del record sull'isamfile");
  return err;
}

//Scrive tutto il contenuto della cache sull'isamfile, aggiungendo, modificando
//o rimuovendo i nodi necessari
int TAnalisi_bil::commit_body(TLocalisamfile &relana) const
{                         
  TRectype rec(LF_RELANA);
  TString status;
  //Estraggo un nodo per volta basandomi sull'assoc_array degli status  
  while (_inter_tree->status_node_items() > 0)                                              
  {
    TRelana_id id;
    int prova = _inter_tree->status_node_items();
    rec= _inter_tree->extract_node(get(ABAN_CODAN), id, status);
    //Ho un rectype e uno status node
    if (status == NODO_AGGIUNTO)
    { 
      if (relana.curr().empty())
      { //Se il cursor di relana è posizionato in modo errato:
        //lo sistemo sull'ultimo record del file
        //DOMANDA: - Perchè ???
        //TENATATIVO DI RISPOSTA: - Quando l'ultima azione effettuata (prima di questa "aggiunta") è la rimozione 
        //  dell'ultimo record probabilmente (ma non sono sicuro) il cursore non è posizionato (o forse
        //  è posizionato in modo errato come ad es. dopo l'EOF, visto che l'EOF era sull'ultimo record rimosso)
        //  e quando eseguo un tentativo di scrittura da un errore di chiave duplicata (anche se questa non esiste);
        //  In tutti gli altri casi (quando l'ultima azione è stata una write o una rewrite o una remove di un record
        //  che non sia l'ultimo) questo problema non esiste.
        //RISPOSTA ESATTA: - Bho !!!
        relana.last();
      }      
      int err = relana.write(rec);
      if (err != NOERR)
        return err;
    }
    if (status == NODO_MODIFICATO)
    {            
      int err = relana.rewrite(rec);
      if (err != NOERR)
        return err;
    }
    if (status == NODO_RIMOSSO)
    {
      relana.read(rec); //Devo leggere sul file per posizionare il cursore: stesso motivo di prima
      int err = relana.remove(rec);
      if (err != NOERR)
        return err;
    }
    // In tutti gli altri casi il nodo non viene modificato
  }
  return NOERR;
}

//Leggo la "testata" del record
int TAnalisi_bil::read(TBaseisamfile& analisi, word isop, word lockop)
{         
  int err=TRectype::read(analisi, isop, lockop);
  if (err==NOERR)
    read_body(FALSE);
  return err;
}

//Leggo la testata del record basandomi sulla posizione
int TAnalisi_bil::readat(TBaseisamfile& analisi, TRecnotype nrec, word lockop)
{
  int err=TRectype::readat(analisi, nrec, lockop);
  if (err==NOERR)
    read_body(FALSE);
  return err;
}

//Leggo il "corpo" del record
int TAnalisi_bil::read_body(bool lock_struct )
{
  if (_relaz) 
  {
    if (_relaz->codtab() != get(ABAN_CODAN))
    {
      delete _relaz;
      delete _ana;
      _relaz=NULL;
      _ana=NULL;
    }
  }
  if (!_relaz) 
  {
    _relaz  = new TAlbero_relvoci(get(ABAN_CODAN));
    _ana    = new TAlbero_relana(get(ABAN_CODAN));
  }
  // carica la copia locale
  TRelana_id id_relana; 
  if (lock_struct)
    _relaz->lock();

  if (_relaz->goto_root())
  {
    if (_ana->goto_root())
      id_relana=_ana->curr().get_real(ABRA_ID);
    naviga_relazioni(id_relana,ID_NULLO,ID_NULLO);
  }                            
  return 0;
}

int TAnalisi_bil::remove(TBaseisamfile& f) const
{
/*Abilitare questa parte solo per effettuare un debug della delete_node
//  anche se messa in questa posizione, la chiamata non ha senso
  TLocalisamfile lf(LF_RELANA);
  TRelana_id id;
  id = 17;
  _inter_tree->delete_node(id);
  int errc = commit_body(lf);
  if (errc != NOERR)
  {             
    message_box("Errore nell'aggiornameno del file dati");
    //return errc;
  }
  return 0;
*/  


//*Abilitare solo questa parte per il test della remove_tree  
  TLocalisamfile lf(LF_RELANA);
  _inter_tree->delete_tree();
  int errc = commit_body(lf);
  if (errc != NOERR)
  {             
    message_box("Errore nell'aggiornameno del file dati");
    //return errc;
  }
  int err = TRectype::remove(f);
  return err;
} 

void TAnalisi_bil::zero() 
{
  _inter_tree->zero();
  TRectype::zero() ;
} 
  
//Naviga l'albero delle relazioni
void TAnalisi_bil::naviga_relazioni(const TRelana_id & begin_relana, const TRelana_id & id_prec,const TRelana_id & id_padre)
{
  TRelana_id id_relana, currid;
  TNodeId key_rel;
  _relaz->curr_id(key_rel);
  _newrec = sincronizza_relana(begin_relana, id_relana);
  currid=_newrec->get_real(ABRA_ID);
  _inter_tree->insert_node(*_newrec,id_prec,id_padre,currid);
  
  //Controllo se c'è un fratello di rel_voci
  if (_relaz->has_rbrother())
  {
    if (_relaz->goto_rbrother())
    { //Fratello di rel_voci trovato
      //Cerco un fratello anche su rel_ana: se non si trova c'è una inconsistenza nei dati
      //fra relvoci e relana
      TRelana_id frat_relana;
      naviga_relazioni(frat_relana,currid , id_padre);
      //_ana->goto_node(key_ana);   //Per risalire al nodo che mi ha chiamato in relana
      _relaz->goto_node(key_rel);
    }
    else
    {//Fratello di rel_voci non  trovato
      error_box ("Errore di consistenza nei dati di relvoci: è previsto un fratello ma non è stato trovato");
    }  
  } // Il record di _relaz non ha un fratello destro
  if (_relaz->goto_firstson())
  { //Figlio di rel_voci trovato
    //Cerco il figlio di rel_ana: se non si trova c'è una inconsistenza nei dati
    //fra relvoci e relana
    if (id_relana!=ID_NULLO)
    { 
      _ana->goto_id(id_relana);
      if (_ana->goto_firstson())
        id_relana=_ana->curr().get_real(ABRA_ID);
    } 
    naviga_relazioni(id_relana, ID_NULLO , currid);
    //_ana->goto_node(key_ana);   //Per risalire al nodo che mi ha chiamato in relana
  }//Se non trovo il figlio di una relazione, potrebbe essere una foglia di un ramo dell'albero
  _relaz->goto_node(key_rel); //Per risalire al nodo che mi ha chiamato in relvoci
}
                       
//Sincronizza relana con quello che trovo in relaz: relaz è navigato da naviga_relazioni
TRectype *TAnalisi_bil::sincronizza_relana(const TRelana_id &begin_relana,TRelana_id &id_relana)
{
  id_relana=begin_relana;
  TToken_string key;
  // ****** caricamento array dei nodi di questo livello dall'isam file LF_RELANA ....
  if (!_relaz->has_lbrother())
  {                                                  
    key = _relaz->curr().get(ABRL_CODVC);
    if (id_relana != ID_NULLO)
    { //carica l'array con i nodi componenti di questa voce (analisi)
      _ana->goto_id(id_relana);
      _nodifratelli.destroy();
      do
      {
        TString codvc =_ana->curr().get(ABRA_CODVC);
        TString idcomp =_ana->curr().get(ABRA_NCOMP);
        _nodifratelli.setkey(codvc,idcomp,key);
        _nodifratelli.add(key,_ana->curr());
      } while (_ana->has_rbrother() && _ana->goto_rbrother());
    }
  }
  
  // ****** ... ricerca il nodo letto da LF_RELVOCI sull'array del livello ...
  // rintraccia il record di relana sull'array 
  TString codvc = _relaz->curr().get(ABRL_CODVC);
  TString idcomp = _relaz->curr().get(ABRL_IDCOMP);
  if (_nodifratelli.find1stkey(codvc,idcomp, key))
  {
    *_newrec = ((TRectype &)_nodifratelli[key]);
    _nodifratelli.mark_used(key); //segna il record nell'array come utilizzato
    id_relana=_newrec->get_real(ABRA_ID);
  }
  else
  {//Il record viene rigenerato con i dati minimi per ripristinare l'integrità degli archivi
    _newrec->zero(); //Azzero l'archivio
    //Lo riempio con i dati basilari
    _newrec->put(ABRA_CODAN,get(ABAN_CODAN));
    _newrec->put(ABRA_ID,ID_NULLO);                 
    _newrec->put(ABRA_TIPOCOD,_relaz->curr().get(ABRL_TIPOCOD));
    _newrec->put(ABRA_CODVC,_relaz->curr().get(ABRL_CODCOMP));
    _newrec->put(ABRA_NCOMP,_relaz->curr().get(ABRL_IDCOMP));
    id_relana = ID_NULLO; // Serve per eseguire correttamente la new_id
    _newrec->put(ABRA_ID,_ana->new_id(id_relana));
    _inter_tree->set_status_node(_newrec->get_real(ABRA_ID),NODO_AGGIUNTO);
  }
  
  // ******** ...scarica l'array
  if (!_relaz->has_rbrother()) // ultimo figlio
  {
    TObject *o;
    _nodifratelli.restart();
    while ((o = _nodifratelli.get()) != NULL)
    {
      if (!_nodifratelli.used(o))  //Marca il record in più su relana come da cancellare
        _inter_tree->set_status_node(((TRectype *)o)->get_real(ABRA_ID),NODO_RIMOSSO);
    }
  }
  return _newrec;
}

// ************
// array interno

void TAnalisi_bil::TArray_fratelli::setkey(const char *tipocod, const char *codvc, TToken_string &key) const
{           
  key.cut(0);
  key.add(tipocod);
  key.add(codvc);
}

bool TAnalisi_bil::TArray_fratelli::find1stkey(const char *tipocod, const char *codvc, TToken_string &key)
{
  TObject *o;
  setkey(tipocod,codvc,key);
  o = objptr((const char *)key);
  return ((o != NULL) && (!((TRectype *)o)->empty()));
}

void TAnalisi_bil::TArray_fratelli::mark_used(const char *key)
{ 
  ((TRectype *)objptr(key))->zero();  // segna il record nell'array come utilizzato
}

bool TAnalisi_bil::TArray_fratelli::used(TObject *o)
{ 
  return ((TRectype *)o)->empty();
}

/**************************************************************************************************/
// TInsert_albero
/**************************************************************************************************/
TInsert_albero::TInsert_albero()
{
// versione definitiva:
//  _currnode = new TRectype(LF_RELANA);
//  _ana_cache = new TRWrecord_cache(new TIsamtempfile(LF_RELANA,"",TRUE,TRUE));

// debug mods:
  _currnode = new TRectype(LF_RELANA);
  _f= new TIsamtempfile(LF_RELANA,"/com/relana",FALSE,FALSE);
  _ana_cache = new TRWrecord_cache(_f);

  //zero(); // resetta l'albero locale
}                       

TInsert_albero::~TInsert_albero()
{                    
  delete _ana_cache;
  delete _f;
}                       

//Setta lo stato del nodo: cioè decide che cosa dovrò fare con questo nodo
void TInsert_albero::set_status_node(const TRelana_id &id, const char *status)
{
  // STATUS A priorità assoluta e rimane sempre A
  // STATUS M priorità su R ma non su A
  // STATUS R priorità sul vuoto ma non su M o A
  // STATUS vuoto: nessuna priorità

  // In TInser_albero::insert_node  posso capire solo A o M ma non R
  // In TAlbero_relana::sincronizza posso capire solo R ma non A e M
  TString key = id.string();
  const TString *prec_status = (const TString *)_status_node.objptr(key);
  
  if (!prec_status)
  { //Elemento ancora non presente nell'array
    _status_node.add(key,TString (status));
  }
  else
  { //Elemento già inserito
    if (stricmp(status,NODO_AGGIUNTO)==0 && (*prec_status != NODO_AGGIUNTO))
      _status_node.add(key,TString (status),TRUE); //Forzo la sovrascrittura in ogni caso
    
    if (stricmp(status,NODO_MODIFICATO)== 0 && (*prec_status != NODO_AGGIUNTO))
    {
      //Se il nodo era già inserito e il suo flag è diverso da NODO_AGGIUNTO
      //allora devo settare che questo nodo è modificato (se non lo è ancora)
      if (*prec_status != NODO_MODIFICATO)
      {
        _status_node.add(key,TString (status),TRUE); //Forzo la sovrascrittura in ogni caso
      } 
      // Arriva qui se il nodo è inserito e il flag era già stato settato da una
      //operazione precedente a NODO_MODIFICATO
    }
    
    if (stricmp(status,NODO_RIMOSSO)==0 && *prec_status != NODO_RIMOSSO)
    { //Sto rimuovento un nodo che prima era stato modificato
      CHECK(FALSE,"Sto rimuovendo un nodo che probabilmente non è da rimuovere");
    }
  }
}

//Restituisce un nuovo id
TRelana_id &TInsert_albero::new_id(TRelana_id id)
{
  if (id == ID_NULLO)
    _last_insert_id+1;
  else
    _last_insert_id = max(_last_insert_id,id);
  return _last_insert_id;
}

//Inserisce il nodo (che ho in ingresso) nella struttura ad albero doppiamente linkata
//di relana aggiornando tutti i link
bool TInsert_albero::insert_node(TRectype & node,const TRelana_id id_prec, const TRelana_id id_padre, TRelana_id id)
{
  TRelana_id id_succ;
  TToken_string key;
  key.add(node.get(ABRA_CODAN));
  TRectype parente(LF_RELANA);
  if (id == ID_NULLO)
    id = new_id(id);
  else
    new_id(id);
  //Cerco il mio fratello precedente 
  if (id_prec != ID_NULLO)
  { //Aggiorno il successivo del mio precedente dicendogli che il suo successivo sono io
    key.add(id_prec.string());
    parente = _ana_cache->get(key);
    parente.put(ABRA_IDSUCC,id.string());
    _ana_cache->put(parente);
    set_status_node(id_prec,NODO_MODIFICATO); //Setto l'eventuale flag di array modificato per il fratello
  }
  else
  { //Se non ho il mio precedente, allora o sono una radice principale o divento il primo figlio:
    if (id_padre != ID_NULLO)
    { //Sono un primo figlio: rintraccio mio padre e gli dico che il suo primo figlio ora, sono io
      key.add(id_padre.string());
      parente = _ana_cache->get(key);
      parente.put(ABRA_IDFIGLIO,id.string());
      _ana_cache->put(parente);
      set_status_node(id_padre,NODO_MODIFICATO); //Setto l'eventuale flag di array modificato per il padre
    } // Sono una radice principale e quindi sono orfana di padre
  }
  
  //Ora aggiorno me stesso
  node.put(ABRA_IDPREC,id_prec.string());
  node.put(ABRA_IDPADRE,id_padre.string());
  node.put(ABRA_IDSUCC,id_succ.string());
  node.put(ABRA_IDFIGLIO,ID_NULLO);
  _ana_cache->put(node);
  //set_current(node);
  goto_node(node);
  set_status_node(id,NODO_MODIFICATO);
  return TRUE;
}


//Questa funzione aggiorna i link dei "parenti" di un nodo che sta per essere rimosso
bool TInsert_albero::delete_node(const TRelana_id &id)
{                 
  
  TRectype parente(LF_RELANA);
  TRelana_id id_padre, id_figlio, id_prec, id_succ;
  
  goto_node(id);
  TToken_string key = _currnode->get(ABRA_CODAN);
  
//  id = _currnode->get_real(ABRA_ID);
  id_padre = _currnode->get_real(ABRA_IDPADRE);
  id_figlio = _currnode->get_real(ABRA_IDFIGLIO);
  id_prec = _currnode->get_real(ABRA_IDPREC);
  id_succ = _currnode->get_real(ABRA_IDSUCC);
  
  //Ricerco il padre per modificare il suo primo figlio, solo se io sono il suo primo figlio
  if (id_padre != ID_NULLO)
  {
    key.add(id_padre.string(),1);
    parente=_ana_cache->get(key); //padre
    if (parente.get(ABRA_IDFIGLIO) == id.string())
    { //Il nodo che sta per essere rimosso è il primo figlio di un padre
      parente.put(ABRA_IDFIGLIO,id_succ.string()); //Aggiorno il padre
      _ana_cache->put(parente);
    }
  }
  
  //Ricerco il mio fratello precedente per dirgli che io non sono più
  //suo fratello successivo, e gli dico anche quale sarà il suo successivo
  if (id_prec != ID_NULLO)
  {
    key.add(id_prec.string(),1);
    parente=_ana_cache->get(key); //fratello sinistro
    parente.put(ABRA_IDSUCC,id_succ.string()); //Assegno al mio fratello sinistro il mio fratello destro
    _ana_cache->put(parente);
  }
  
  //Dico a mio fratello successivo chi il suo precedente non sono più io,
  //e gli dico che il suo precedente è il MIO precedente
  if (id_succ != ID_NULLO)
  {
    key.add(id_succ.string(),1);
    parente=_ana_cache->get(key); //fratello destro
    parente.put(ABRA_IDPREC,id_prec.string()); //Assegno al mio fratello destro il mio fratello sinistro
    _ana_cache->put(parente);
  }
  
  //I miei vicini mi hanno già escluso: non sono più raggiungibile
  //Ricostruisco la chiave
  //Elimino i miei link dai fratelli
  key.add(id.string(),1);
  //node.put(ABRA_IDPADRE,ID_NULLO);
  _currnode->put(ABRA_IDPREC,ID_NULLO);
  _currnode->put(ABRA_IDSUCC,ID_NULLO);
  _ana_cache->put(*_currnode);
  //Elimino i miei figli
  
  TRelana_id nextnode_id;
  if (id_prec != ID_NULLO)
  {
    nextnode_id = id_prec;
  }
  else
  {
    if (id_succ != ID_NULLO)
    {
      nextnode_id = id_succ;
    }
    else
    {
      if (id_padre != ID_NULLO)
      {
        nextnode_id = id_padre;
      }
      else
      {
        CHECK (FALSE,"NON SO DOVE POSIZIONARMI !!!!");
      }
    }
  }
  remove_subtree(nextnode_id);
  //A questo punto l'assoc_array degli status è già completamente aggiornato
  //write_cache();  //Solo per debug
  return TRUE;
}

void TInsert_albero::zero()
{
  delete_tree();  // cancella l'albero
  _status_node.destroy(); 
  _currnode->put(ABRA_ID,ID_NULLO);
}

bool TInsert_albero::delete_tree()
{
  goto_root();
  remove_subtree(ID_NULLO); //Non eliminando il link coi fratelli della radice, remove_subtree naviga tutto l'albero
  return TRUE;
}

//Questa funzione elimina tutti i nodi sottostanti al nodo
//"principale" che sta per essere eliminato
bool TInsert_albero::remove_subtree(const TRelana_id thisnode_id)
{
  TRelana_id myself_id;
  //cerco il figlio
  if (has_son())
  {                
    myself_id = _currnode->get_real(ABRA_ID);
    goto_firstson();
    remove_subtree(myself_id);
  }
  
  //cerco il fratello
  if (has_rbrother())
  {
    myself_id = _currnode->get_real(ABRA_ID);
    goto_rbrother();
    remove_subtree(myself_id);
  }                              
  TRelana_id id = _currnode->get(ABRA_ID);
  
  //Questa parte esegue la gestione dell'assoc_array degli stati
  //in modo tale da mantenerlo allineato con il contenuto della cache
  TString *status;
  status = (TString*)_status_node.objptr(id.string());
  if (status != ID_NULLO)
  {//Se esiste uno stato per questo nodo
    if ((*status == NODO_MODIFICATO) || (*status == NODO_RIMOSSO))
    {//In questi due casi il nodo esisteva già nel file originario
      _status_node.add(id.string(),(TString)NODO_RIMOSSO,TRUE); //Forzo la sovrascrittura in ogni caso
    }
    else
    {//Nel caso di NODO_AGGIUNTO
      _status_node.remove(id.string());
    }
  }
  else
  {
    //Questo caso non dovrebbe verificarsi poichè un nodo per cui
    //non è previsto uno status, non dovrebbe esistere nella cache
    CHECK (FALSE,"Errore nella consistenza della cache");
  }
  if (thisnode_id != ID_NULLO)
    goto_node(thisnode_id);
  else
    _currnode->put(ABRA_ID,ID_NULLO);

  return TRUE;
}

bool TInsert_albero::has_son()
{
  return (_currnode->get_real(ABRA_IDFIGLIO) != ID_NULLO);
}

bool TInsert_albero::goto_firstson()
{
  goto_node(_currnode->get_real(ABRA_IDFIGLIO));
  return TRUE;
}

bool TInsert_albero::has_rbrother()
{
  return (_currnode->get_real(ABRA_IDSUCC) != ID_NULLO);
}

bool TInsert_albero::goto_rbrother()
{
  goto_node(_currnode->get_real(ABRA_IDSUCC));
  return TRUE;
}

bool TInsert_albero::goto_root()
{ //Il _current sarà posizionato sull'ultimo nodo che è stato visitato
  if (current()->get_real(ABRA_ID)==ID_NULLO)
    return FALSE;
  TToken_string key;
  TRelana_id id_prec, id_padre;
  key.add(_currnode->get(ABRA_CODAN));
  key.add(_currnode->get(ABRA_ID));
  do
  {
    *_currnode = _ana_cache->get(key);
    id_prec = _currnode->get_real(ABRA_IDPREC);
    id_padre = _currnode->get_real(ABRA_IDPADRE);
    if (id_prec != ID_NULLO)
    {
      key.add(id_prec.string(),1);
    }
    else
    {
      if (id_padre != ID_NULLO)
        key.add(id_padre.string(),1);
    }
  } while (id_prec != ID_NULLO || id_padre != ID_NULLO);
  return TRUE;
}

/**************************************************************************************************/
//  TAlbero_relana
/**************************************************************************************************/
//In questo costruttore cerco di capire anche quale è l'ultimo id utilizzato
TAlbero_relana::TAlbero_relana( const char * tabcode)
{
  _codtab=tabcode;
  _relana=new TLocalisamfile(LF_RELANA);
  _relana->put(ABRA_CODAN,_codtab);
  _relana->put(ABRA_ID,MAX_ID_REL);
  
  //Trova l'ultimo id usato in relana: DA COMPLETARE !!!
  int err = _relana->read(_isgteq);  //Codifica errori in TIsamerr
  if (err == NOERR)
  { // Ho trovato il primo della tabella successiva: leggendo il precedente
    // ho l'ultimo record dalla tabella cercata
    _relana->prev();
    if (_relana->get(ABRA_CODAN) != _codtab)
    { // Non esiste la tabella
      ; //_last_id viene lasciato a 0
    }
    _last_id = _relana->get_real(ABRA_ID);
  }
  
  if (err == _isemptyfile)
  { //Il file è vuoto
    ;//_last_id viene lasciato a 0
  }
  
  if (err == _iseof)
  { // La tabella successiva non esiste: provo a leggere l'ultimo record
    _relana->last();
    if (_relana->get(ABRA_CODAN) != _codtab)
    { //Tabella non trovata
      ; //_last_id viene lasciato a 0
    }
    //Tabella trovata: prendo l'id dell'ultimo record
    _last_id = _relana->get_real(ABRA_ID);
  }
}

TAlbero_relana::~TAlbero_relana() 
{
  delete _relana;
}
 
//Incremento l'id per dare il primo id disponibile
TRelana_id & TAlbero_relana::new_id(TRelana_id id)
{      
  if (id == ID_NULLO)
    _last_id = _last_id+1;
  else
    _last_id = max(_last_id,id);
  return _last_id;
}

//Posiziona relana sul record voluto
bool TAlbero_relana::goto_id(const TRelana_id &id)
{
  _relana->put(ABRA_CODAN,_codtab);
  _relana->put(ABRA_ID,id);
  if (_relana->read() == NOERR)
    return TRUE;
  return FALSE; //Non sono riuscito a posizionarmi sul nodo
} 
 
bool TAlbero_relana::lock()
{
  //Potrebbe usare come parametro _codtab
  return TRUE;
} 

void TAlbero_relana::unlock()
{                                        
  //Potrebbe usare come parametro _codtab
  return ;
}

//Ricerca la radice di relana
bool TAlbero_relana::goto_root()
{
  _relana->put(ABRA_CODAN,_codtab); //Ricerca il codice della tabella: è l'unica cosa che conosco
  //No so nulla sull'id
  _relana->read(_isgteq); //Leggo la prima chiave che si avvicina a quella specificata
  if (_relana->get(ABRA_CODAN) == _codtab)
  {       
    while (has_father())
    { 
      goto_father();
    } // Ho raggiunto il primo livello
    while (has_lbrother())
    {
      goto_lbrother();
    }// Ho raggiunto la radice
    return TRUE;
  }        
  //Non ho trovato una voce con codice tabella richiesta
  return FALSE;
}

//Dice se un nodo di relana ha il primo figlio
bool TAlbero_relana::has_son() const
{                                         
  return _relana->get_real(ABRA_IDFIGLIO)!=ID_NULLO;
}

//Ricerca il primo filglio di un nodo di relana
bool TAlbero_relana::goto_firstson()
{                                         
  TRelana_id id_figlio(_relana->get_real(ABRA_IDFIGLIO));
  if (id_figlio > 0)
  { //Ci deve essere un figlio: lo cerco
    //Il CODAN deve rimanere uguale a quello del padre
    _relana->put(ABRA_ID,_relana->get(ABRA_IDFIGLIO));
    if (_relana->read() == NOERR)
      return TRUE;  //Figlio trovato con successo
  }
  //Non c'è un figlio: non si dovrebbe mai verificare visto che
  //si entra in questa funzione solo quando è previsto che ci sia un figlio.
  return FALSE;
}          

//Dice se un nodo di relana ha un fratello destro
bool TAlbero_relana::has_rbrother() const 
{              
  return _relana->get_real(ABRA_IDSUCC) != ID_NULLO;
}

//Ricerca il fratello destro di un nodo di relana
bool TAlbero_relana::goto_rbrother() 
{
  TRelana_id id_fratello(_relana->get_real(ABRA_IDSUCC));
  if (id_fratello > 0)
  { //Ci deve essere un fratello: lo cerco
    //Il CODAN deve rimanere uguale a quello del fratello precedente
    _relana->put(ABRA_ID,_relana->get(ABRA_IDSUCC));
    if (_relana->read() == NOERR)
      return TRUE; //Fratello trovato con successo
  }
  //Non c'è un fratello: non si dovrebbe mai verificare visto che
  //si entra in questa funzione solo quando è previsto che ci sia un fratello.
  return FALSE;
}

//Dice se un nodo di relana ha un padre
bool TAlbero_relana::has_father() const 
{ 
  return _relana->get_real(ABRA_IDPADRE) != ID_NULLO;
}

//Ricerca il padre del nodo di relana
bool TAlbero_relana::goto_father()
{
  _relana->put(ABRA_ID,_relana->get(ABRA_IDPADRE));
  if (_relana->read() != NOERR)
    CHECK (FALSE,"ERRORE DI PADRE"); //*!*!*!*! DA gestire
  else
    return TRUE;
  return FALSE;
}
 
//Ritrona il nodo corrente di relana
TObject *TAlbero_relana::curr_node() const 
{
  return &_relana->curr();
}

//Dice se un nodo di relana ha un fratello sinistro
bool TAlbero_relana::has_lbrother() const 
{
  return _relana->get_real(ABRA_IDPREC) != ID_NULLO;
}

//Ricerca il fratello sinistro di un nodo di relana
bool TAlbero_relana::goto_lbrother()
{
  TRelana_id id_fratello(_relana->get_real(ABRA_IDPREC));
  if (id_fratello > 0)
  {//Ci deve essere un fratello: lo cerco
    //Il CODAN deve rimanere uguale a quello del fratello successivo
    _relana->put(ABRA_ID,_relana->get(ABRA_IDPREC));
    if (_relana->read() == NOERR)
      return TRUE; //Fratello trovato con successo
  }
  //ERRORE !!!
  return FALSE;
}

void TAlbero_relana::node2id(const TObject * node,TNodeId & id) const
{
  id.format("%ld",(long)_relana->recno()); 
}

/**************************************************************************************************/
//  TAlbero_relvoci
/**************************************************************************************************/
TAlbero_relvoci::TAlbero_relvoci(const char * tabcode) 
{
  _codtab=tabcode;
  _relvoci=new TLocalisamfile(LF_RELVOCI);
}

TAlbero_relvoci::~TAlbero_relvoci() 
{
  delete _relvoci;
}
  
//Ricerca la radice di relvoci
bool TAlbero_relvoci::goto_root()
{
  _relvoci->put(ABRL_TIPOCOD,TIPO_ANALISI);             // La radice ha tipocod = "A"
  TString codtab = _codtab;                           //Mi serve per eseguire una formattazione senza modificare _codtab
  _relvoci->put(ABRL_CODVC,codtab.right_just(10,' '));  //Inserisco il codice della tabella su cui sto lavorando
  //No so nulla sull'id
  _relvoci->read(_isgteq);                              //Leggo la prima chiave che si avvicina a quella specificata
  if ((_relvoci->get(ABRL_TIPOCOD) == TIPO_ANALISI) || (_relvoci->get(ABRL_CODVC) == _codtab))
  {
    while (has_lbrother())
    {
      goto_lbrother();
    }
    return TRUE;
  }                                                     
  //Non ho trovato una voce di analisi richiesta o
  //non ho trovato una voce con codice tabella richiesta
  return FALSE;
}

bool TAlbero_relvoci::lock()
{
  //Potrebbe usare come parametro _codtab
  return TRUE;
} 


void TAlbero_relvoci::unlock()
{                                        
  //Potrebbe usare come parametro _codtab
  return ;
}

//Dice se il nodo ha un primo figlio; DA DEFINIRE
bool TAlbero_relvoci::has_son() const
{
  CHECK(FALSE,"!!!");
  return FALSE;
}

//Ricerca il primo figlio di un nodo di relvoci
bool TAlbero_relvoci::goto_firstson()
{               
  TRecnotype temp_pos = _relvoci->recno();
  
  _relvoci->put(ABRL_TIPOCOD,TIPO_VOCE); //Il tipo codice del filgio di una radice o di un livello inferiore è sempre "V"
  TString controllo_comp = _relvoci->get(ABRL_CODCOMP);
  _relvoci->put(ABRL_CODVC,controllo_comp); //Setto il figlio
  //Non posso sapere nulla sull'id corretto: lo azzero perchè il record contiene già l'id del record letto in precedenza
  //e leggo la prima chiave che assomiglia a quella settata
  _relvoci->put(ABRL_IDCOMP,0);
  _relvoci->read(_isgteq); //Leggo la prima chiave che si avvicina a quella specificata
  
  if ((_relvoci->get(ABRL_TIPOCOD) == TIPO_VOCE) && (_relvoci->get(ABRL_CODVC) == controllo_comp))
  {//Ho trovato un figlio, ma non so se è proprio il primo figlio:
   //se non sono sul primo figlio navigo all'indietro
    while (has_lbrother())
    {
      goto_lbrother();
    }
    return TRUE;
  }
  else
  { //Non ho trovato il filgio: mi riposiziono alla posizione precedente
    //Questo non rappresenta un errore perchè potrebbe essere 
    //la foglia di un ramo dell'albero
    _relvoci->readat(temp_pos);
    return FALSE;
  }
}

//Dice su un nodo di relvoci ha un fratello destro
bool TAlbero_relvoci::has_rbrother() const 
{                                 
  return _relvoci->get_long(ABRL_NEXTCOMP) != ID_NULLO;  
}

//Ricerca il fratello destro di un nodo di relvoci
bool TAlbero_relvoci::goto_rbrother()
{             
  //Il tipocod di un fratello deve essere uguale a quello attuale
  //Il codice voce di un fratello deve essere uguale a quella attuale
  _relvoci->put(ABRL_IDCOMP,_relvoci->get(ABRL_NEXTCOMP)); //Assegno all'id il successivo
  if (_relvoci->read() == NOERR)
    return TRUE; //Fratello trovato
  else
    return FALSE; //Fratello non trovato
}

//Dice se un nodo di relvoci ha un fratello sinistro
bool TAlbero_relvoci::has_lbrother() const 
{                                 
  return _relvoci->get_long(ABRL_PREVCOMP) != ID_NULLO;  
}

//Ricerca il fratello sinistro di un nodo di relvoci
bool TAlbero_relvoci::goto_lbrother()
{             
  //Il tipocod di un fratello deve essere uguale a quello attuale
  //Il codice voce di un fratello deve essere uguale a quella attuale
  _relvoci->put(ABRL_IDCOMP,_relvoci->get(ABRL_PREVCOMP)); //Assegno all'id il successivo
  if (_relvoci->read() == NOERR)
    return TRUE; //Fratello trovato
  else
    return FALSE; //Fratello non trovato
}  

//Ritorna il nodo corrente di relvoci
TObject *TAlbero_relvoci::curr_node() const 
{
  return &_relvoci->curr();
}

void TAlbero_relvoci::node2id(const TObject * node,TNodeId &  id) const
{
  id.format("%ld",_relvoci->recno()); 
}