campo-sirio/ef/ef0101.cpp

#include "effetti.h"         
#include "reffetti.h"
#include "cession.h"
#include "ef0101.h"

// costruttore di default 
TEffetto::TEffetto()
          : TRectype(LF_EFFETTI), _righe(LF_REFFETTI, "NRIGATR"), _cess(LF_CESS, "NRIGA")
{                                 
}

// costuisce l'effetto con il record passato
TEffetto::TEffetto(TRectype& rec)
          : TRectype(LF_EFFETTI), _righe(LF_REFFETTI, "NRIGATR"), _cess(LF_CESS, "NRIGA")
{        
   TLocalisamfile f(LF_EFFETTI);
   read(f,rec);                           
}

//setta i campi per la prima chiave (nprogtr) del file 
void TEffetto::put_key(TRectype& rec, long numeff) const
{
  CHECKD(numeff >= 0, "Numero effetto non valido ", numeff);
  rec.put("NPROGTR",numeff);
}

//setta i campi per la quarta chiave (tipodist+ndist+nrigadist) del file 
void TEffetto::put_key(TRectype& rec,char tipodist, long ndist, long nrigadist)
{
  CHECK(tipodist == 'I' || tipodist == 'S' || tipodist == 'B' || tipodist == 0, "Tipo distinta");
  CHECKD(ndist >= 0, "Numero distinta non valido ", ndist);
  CHECKD(nrigadist >= 0, "Numero riga distinta non valido ", nrigadist);
  rec.put("TIPODIST", tipodist); 
  rec.put("NDIST", ndist);
  rec.put("NRIGADIST", nrigadist);
}

// ritorna la prossima chiave utilizzabile (il prossimo numero progressivo) 
long TEffetto::get_next_key(const long codcf) const
{               
  static long n = 0;
  if (n == 0)
  {
    TLocalisamfile eff(LF_EFFETTI);
    TRectype& curr = eff.curr();
    put_key(curr, 9999999L);
    const int err = eff.read(_isgreat);
    if (err != _isemptyfile)
    {
      if (err == NOERR)
        eff.prev();
      if (curr.get_long("CODCF")==codcf)
        n = curr.get_long("NPROGTR");
    }     
  }      
  n++;
  return n;   
}

// rinumera la chiave 1
long TEffetto::renum(long numeff)
{
  if (numeff <= 0)
  {                             
    long codcf = codicec();
    numeff  = get_next_key(codcf);
  }   
  char num[7]; sprintf(num, "%ld", numeff);
  renum_key("NPROGTR", num);        // aggiorna testata
  _righe.renum_key("NPROGTR", num); // aggiorna righe ok
  _cess.renum_key("NPROGTR", num);  // aggiorna cessionari ok
  return numeff;
}

// restituisce il prossimo effetto
int TEffetto::next(TBaseisamfile& f)
{ 
  const int err = f.next(); 
  *this = f.curr();
  return err;  
}

// permette di leggere il record passato nel file passato, comune alla lettura 
// per chiave 1 e per chiave 4 
int TEffetto::leggi(TLocalisamfile &f, const TRectype& r)   
{ 
  int err = TRectype::read(f); 
  const long nu = numero();
  TRectype *k_reff = new TRectype(LF_REFFETTI),//necessari per poter andare a leggere i due record array
           *k_cess = new TRectype(LF_CESS);    //cessionari e righe effetto 
  put_key(*k_reff, nu);
  put_key(*k_cess, nu);
  if (err == NOERR)
  {
    _righe.read(k_reff); 
    _cess.read(k_cess);
  }  
  else
  {
    head() = r;          
    const long nu = numero();
    put_key(*k_reff, nu);
    put_key(*k_cess, nu);
    if (nu !=0)
    { 
      destroy_rows_r();
      destroy_rows_c();
      _cess.set_key(k_cess);
      _righe.set_key(k_reff); 
    }
  }  
  return err;    
}

// legge il record passato, con chiave 1
int TEffetto::read(TLocalisamfile& f, const TRectype& rec)
{ 
  head() = rec;  
  return leggi(f, rec); 
}

// legge l'effetto usando la chiave 4
int TEffetto::read(TLocalisamfile& f, char tipodist, long ndist, long nrigadist)
{ 
  f.setkey(4);                        
  TRectype rec(LF_EFFETTI);
  put_key(rec, tipodist, ndist, nrigadist);   
  head() = rec;
  int err = leggi(f, rec);
  return err;
}

// scrive l'effetto, usando la chiave 1
int TEffetto::write(TLocalisamfile& f, bool force)
{ 
  const bool nuovo = numero() <= 0;            // E' nuovo!
  if (nuovo && force)                          // quindi ...
    force = FALSE;                             // ... non fare la rewrite
  f.setkey(1);//per evitare problemi in quanto la chiave 4 e' duplicabile
  int err = NOERR;
  if (force)
  {
    if ((err=_righe.write(force)) == NOERR) err= _cess.write(force); 
    if (err == NOERR)
    {
      err = TRectype::rewrite(f);
      if (err != NOERR)
        err = TRectype::write(f);
    }
   }     
   else
  {             
    if (nuovo)
    {         
      TEffetto& myself = *(TEffetto*)this;
      if (numero() <= 0)
        myself.renum();
      do
      {
        err = TRectype::write(f);
        if (err == _isreinsert)
          myself.renum();
      } while (err == _isreinsert);
     }
    else 
    {
      err = TRectype::write(f);
      if (err != NOERR)
        err = TRectype::rewrite(f);
    }    
    if (err == NOERR)
      if ((err=_righe.write(force)) == NOERR) err= _cess.write(force); 
  }
  return err;  
}

// rimuove l'effetto
int TEffetto::remove(TLocalisamfile& f)const
{     
  int err;
  if ((err=_righe.remove()) == NOERR) err= _cess.remove(); 
  if (err == NOERR)
    err = TRectype::remove(f);
  return err;  
}