campo-sirio/ca/calib02.cpp

#include <xvt.h>

#include "calib01.h"
#include "calib02.h"

#include "../cg/cglib01.h"

#include <rdoc.h>
#include <pconti.h>

#include "movana.h"
#include "pconana.h"
#include "rmovana.h"
#include "saldana.h"

///////////////////////////////////////////////////////////
// TPconana_recordset
///////////////////////////////////////////////////////////

const TVariant& TPconana_recordset::get(const char* field) const
{
  const TFixed_string column_name(field);
  if (column_name[0] == '#')
  {
    if (column_name == "#CMSCDC")
    {
      const TMultilevel_code_info& info = ca_multilevel_code_info(LF_FASI);
      switch (info.parent())
      {
      case LF_CDC     : return get_tmp_var() = _bill.costo();
      case LF_COMMESSE: return get_tmp_var() = _bill.commessa();
      default         : return NULL_VARIANT; 
      }
    }
    if (column_name == "#COSTO")
      return get_tmp_var() = _bill.costo();
    if (column_name == "#COMMESSA")
      return get_tmp_var() = _bill.commessa();
    if (column_name == "#FASE")
      return get_tmp_var() = _bill.fase();
  }
  else
  {
    const TRectype& curr = relation()->curr();
    if (column_name.starts_with(PCONANA_CODCONTO))
    {
      TString80 str;
      if (_tipo == 'C')
      {
        const TBill b(curr);
        str = b.string(0x8);
      }
      else
        str = curr.get(PCONANA_CODCONTO);

      if (column_name[8] == ':')
      {
        const TMultilevel_code_info& info = ca_multilevel_code_info(_tipo == 'C' ? LF_PCON : LF_PCONANA);
        const int level = column_name[9] - '1';
        str.cut(info.total_len(level));
      }
      return get_tmp_var() = str;
    }
    if (column_name.starts_with(PCONANA_DESCR))
    {
      TString80 str;
      if (_tipo == 'C')
      {
        TBill b(curr);
        if (column_name[5] == ':')
        {
          if (column_name[6] == '1')
            b.set(b.gruppo(), 0, 0); else
          if (column_name[6] == '2')
            b.set(b.gruppo(), b.conto(), 0);
        }
        str = b.descrizione();
      }
      else
      {
        if (column_name[5] == ':')
        {
          const TMultilevel_code_info& info = ca_multilevel_code_info(LF_PCONANA);
          const int level = column_name[6] - '1';
          str = curr.get(PCONANA_CODCONTO);
          str.cut(info.total_len(level));
          str = cache().get(LF_PCONANA, str, PCONANA_DESCR);
        }
        else
          str = curr.get(PCONANA_DESCR);
      }
      return get_tmp_var() = str;
    }
    if (column_name == PCONANA_INDBIL)
    {
      long ib = curr.get_int(PCONANA_INDBIL);
      if (ib == 0)
      {
        if (_tipo == 'C')
        {
          TBill b(curr);
          ib = b.indicatore_bilancio(); 
        }
        else
        {
          const TString80 conto = curr.get(PCONANA_CODCONTO);
          const TMultilevel_code_info& info = ca_multilevel_code_info(LF_PCONANA);
          for (int i = info.levels()-2; i >= 0 && ib <= 0; i--)
          {
            const TString& k = conto.left(info.total_len(i));
            const TRectype& pca = cache().get(LF_PCONANA, conto);
            ib = pca.get_long(PCONANA_INDBIL);
          }
        }
      }
      return get_tmp_var() = ib;
    }

    if (column_name.starts_with("SALDO:"))
    {
      TString16 sub_field = column_name.mid(6);
      const char last = sub_field.right(1)[0];
      int tipimov = 0;
      switch (last)
      {
      case 'C': tipimov = _saldanal_consuntivo; sub_field.rtrim(1); break; // Consuntivo
      case 'P': 
      case 'V': tipimov = _saldanal_preventivi; sub_field.rtrim(1); break; // Preventivo o variazione preventivo
      default : tipimov = _tipimov; break;
      }

      ((TAnal_bill&)_bill).set_conto(get(PCONANA_CODCONTO).as_string());
      const TSaldanal& s = ca_saldo(_bill, _dal, _al, tipimov);

      TVariant& var = get_tmp_var();
      if (sub_field == "INI_DARE")
      {
        var = s._ini.sezione() == 'D' ? s._ini.valore() : ZERO; 
      } else
      if (sub_field == "INI_AVERE")
      {
        var = s._ini.sezione() == 'A' ? s._ini.valore() : ZERO; 
      } else
      if (sub_field == "MOV_DARE")
      {
        var = s._dare.valore(); 
      } else
      if (sub_field == "MOV_AVERE")
      {
        var = s._avere.valore(); 
      } else
      if (sub_field == "FIN_DARE")
      {
        var = s._fin.sezione() == 'D' ? s._fin.valore() : ZERO;     
      } else
      if (sub_field == "FIN_AVERE")
      {
        var = s._fin.sezione() == 'A' ? s._fin.valore() : ZERO;     
      }
      return var;
    }
  }
  return TISAM_recordset::get(column_name);
}

bool TPconana_recordset::valid_record(const TRelation& rel) const
{
  TString80 conto;
  if (_tipo == 'C')
  {
    const TBill b(rel.curr());
    if (b.sottoconto() <= 0 || !b.is_analitico())
      return false;
    conto = b.string(0x8);
  }
  else
  {
    conto = rel.curr().get(PCONANA_CODCONTO);
    if (conto.len() <= _conto_minlen)
      return false;
  }

  if (_movimentati || _nonnulli)
  {
    ((TAnal_bill&)_bill).set_conto(conto);
    const TSaldanal& s = ca_saldo(_bill, _dal, _al, _tipimov);
    if (_movimentati && !s._movimentato)
      return false;
    if (_nonnulli && s._fin.is_zero())
      return false;
  }
  return true;
}
  
static const TPconana_recordset* _current_recset = NULL;

bool TPconana_recordset::pianoconti_filter(const TRelation* rel)
{ return _current_recset->valid_record(*rel); }

void TPconana_recordset::set_custom_filter(TCursor& cursor) const 
{
  if (_tipo == 'C')
  {
    TRectype darec(LF_PCON), arec(LF_PCON);
    darec.put(PCN_GRUPPO,     _da_conto.mid(0,3));
    darec.put(PCN_CONTO,      _da_conto.mid(3,3));
    darec.put(PCN_SOTTOCONTO, _da_conto.mid(6,6));
    arec.put(PCN_GRUPPO,      _a_conto.mid(0,3));
    arec.put(PCN_CONTO,       _a_conto.mid(3,3));
    arec.put(PCN_SOTTOCONTO,  _a_conto.mid(6,6));
    cursor.setregion(darec, arec);
  }
  else
  {
    TRectype darec(LF_PCONANA), arec(LF_PCONANA);
    darec.put(PCONANA_CODCONTO, _da_conto);
    arec.put(PCONANA_CODCONTO, _a_conto);
    cursor.setregion(darec, arec);
  }

  _current_recset = this;
  cursor.set_filterfunction(pianoconti_filter);
}

void TPconana_recordset::set_tipo(char tipo)
{
  if (tipo != 'A' && tipo != 'C')
  {
    TConfig_anal cfg;
    tipo = cfg.get_bool("UsePdcc") ? 'C' : 'A';
  }
  _tipo = tipo;

  if (_tipo == 'A')
  {
    set("USE PCONANA");
    const TMultilevel_code_info& info = ca_multilevel_code_info(LF_PCONANA);
    _conto_minlen = info.total_len(-1);  // Lunghezza fino al penultimo livello
  }
  else
  {
    set("USE PCON");
    _conto_minlen = 6;  // Gruppo(3)+Conto(3)
  }
}

void TPconana_recordset::set_filter(char tipo, const char* da_conto, const char* a_conto,
                                    const char* costo, const char* commessa, const char* fase,
                                    const TDate& dal, const TDate& al,
                                    word tipimov, bool movimentati, bool nonnulli)
{
  set_tipo(tipo);

  _da_conto = da_conto;
  _a_conto = a_conto;
    
  _dal = dal;
  _al = al;

  _tipimov= tipimov;
  _movimentati = movimentati;
  _nonnulli = nonnulli;

  _bill.reset();
  _bill.set_costo(costo);
  _bill.set_commessa(commessa);
  _bill.set_fase(fase);
}

TPconana_recordset::TPconana_recordset(char tipo) : TISAM_recordset("USE PCONANA")
{ 
  set_tipo(tipo);
}

///////////////////////////////////////////////////////////
// TAnal_report
///////////////////////////////////////////////////////////

size_t TAnal_report::get_usr_words(TString_array& words) const
{
  TReport::get_usr_words(words);
  
  const char* const name[] = 
  { 
    "CA_FORMAT_COSTO", 
    "CA_FORMAT_COMMESSA", 
    "CA_FORMAT_FASE", 
    "CA_FORMAT_CONTO", 
    "CA_FORMAT_CMSCDC", 
    NULL
  };

  ((TAnal_report*)this)->_first_msg = words.items(); // Calcola il primo numero disponibile
  size_t i; 
  for (i = 0; name[i] != NULL; i++)
    words.add(name[i]);
  
  return words.items();
}

void TAnal_report::msg_format(int logicnum, TVariant_stack& stack)
{
  const TString& str_in = curr_field()->get().as_string();
  if (str_in.not_empty())
  {
    TString80 separator = " ";
    if (stack.items() > 0)
      separator = stack.pop().as_string();
    if (separator.not_empty())
    {
      const TMultilevel_code_info& mci = ca_multilevel_code_info(logicnum);
      TString80 str_out = str_in;
      for (int i = mci.levels()-2; i >= 0; i--)
        str_out.insert(separator, mci.total_len(i));
      curr_field()->set(str_out);
    }
  }
}

void TAnal_report::msg_format_costo   (TVariant_stack& stack)
{ msg_format(LF_CDC, stack); }

void TAnal_report::msg_format_commessa(TVariant_stack& stack)
{ msg_format(LF_COMMESSE, stack); }

void TAnal_report::msg_format_fase    (TVariant_stack& stack)
{ msg_format(LF_FASI, stack); }

void TAnal_report::msg_format_conto   (TVariant_stack& stack)
{ 
  // Cerca di determinare se si usa il piano contabile o analitico
  const TFixed_string gruppo(PCN_GRUPPO);
  TVariant var;
  get_record_field(gruppo, var);
  if (var.is_null())
    msg_format(LF_PCONANA, stack); 
  else
    msg_format(LF_PCON, stack); 
}

void TAnal_report::msg_format_commessa_costo(TVariant_stack& stack)
{
  const TMultilevel_code_info& main_info = ca_multilevel_code_info(LF_FASI);
	msg_format(main_info.parent(), stack);
}

bool TAnal_report::execute_usr_word(unsigned int opcode, TVariant_stack& stack)
{
  if (opcode < _first_msg)
    return TReport::execute_usr_word(opcode, stack);
  opcode -= _first_msg;
  switch (opcode)
  {
  case 0 : msg_format_costo(stack);          break;
  case 1 : msg_format_commessa(stack);       break;
  case 2 : msg_format_fase(stack);           break;
  case 3 : msg_format_conto(stack);          break;
  case 4 : msg_format_commessa_costo(stack); break;
  default: break;
  }
  return true;
}

///////////////////////////////////////////////////////////
// TAnal_bill
///////////////////////////////////////////////////////////

int TAnal_bill::compare(const TSortable& s) const
{
  const TAnal_bill& b = (const TAnal_bill&)s;
  int cmp = _conto.compare(b._conto);
  if (cmp == 0)
  {
    cmp = _costo.compare(b._costo);
    if (cmp == 0)
    {
      cmp = _commessa.compare(b._commessa);
      if (cmp == 0)
        cmp = _fase.compare(b._fase);    
    }
  }
  return cmp;
}
  
bool TAnal_bill::match(const TAnal_bill& b) const
{
  if (b._conto.not_empty() && _conto != b._conto)
    return false;
  if (b._costo.not_empty() && _costo != b._costo)
    return false;
  if (b._commessa.not_empty() && _commessa != b._commessa)
    return false;
  if (b._fase.not_empty() && _fase != b._fase)
    return false;
  return true;
}

void TAnal_bill::set_conto(const char* c)
{ _conto = c; _conto.trim(); }

void TAnal_bill::set_costo(const char* c)
{ _costo = c; _costo.trim(); }

void TAnal_bill::set_commessa(const char* c)
{ _commessa = c; _commessa.trim(); }

void TAnal_bill::set_fase(const char* c)
{ _fase = c; _fase.trim(); }

const TString&  TAnal_bill::conto() const
{ return _conto; }

const TString& TAnal_bill::costo() const
{ return _costo; }

const TString& TAnal_bill::commessa() const
{ return _commessa; }

const TString& TAnal_bill::fase() const
{ return _fase; }

void TAnal_bill::reset()
{
  _conto = _costo = _commessa = _fase = "";
}

bool TAnal_bill::get(const TRectype& rec)
{
  bool ok = true;
  reset();
  switch(rec.num())
  {
  case LF_RMOVANA: 
    set_conto(rec.get(RMOVANA_CODCONTO));
    set_costo(rec.get(RMOVANA_CODCCOSTO));
    set_commessa(rec.get(RMOVANA_CODCMS));
    set_fase(rec.get(RMOVANA_CODFASE));
    break;
  case LF_RIGHEDOC:
    set_commessa(RDOC_CODCMS);
    set_fase(RDOC_FASCMS);
    break;
  case LF_SALDANA:
    set_conto(rec.get(SALDANA_CONTO));
    set_costo(rec.get(SALDANA_COSTO));
    set_commessa(rec.get(SALDANA_COMMESSA));
    set_fase(rec.get(SALDANA_FASE));
    break;
  default: 
    ok = false;
    break;
  }
  return ok;
}

void TAnal_bill::copy(const TAnal_bill& b)
{
  set_conto(b.conto());
  set_costo(b.costo());
  set_commessa(b.commessa());
  set_fase(b.fase());
}

const TAnal_bill& TAnal_bill::operator=(const TAnal_bill& b)
{ 
  copy(b); 
  return *this;
}

TAnal_bill::TAnal_bill()
{ }

TAnal_bill::TAnal_bill(const TAnal_bill& b)
{ copy(b); }

TAnal_bill::TAnal_bill(const char* conto, const char* costo, const char* commessa, const char* fase)
{
  set_conto(conto);
  set_costo(costo);
  set_commessa(commessa);
  set_fase(fase);
}

TAnal_bill::TAnal_bill(const TRectype& rec)
{
  get(rec);
}

////////////////////////////////////////////////////////
// TRiclassify_cache
////////////////////////////////////////////////////////

class TRiclassify_cache : public TCache
{
  int _conto_min;

protected:
  virtual TObject* key2obj(const char* key);
  void extract(const TString& conto, TString_array& conti) const;

public:
  const TString_array& conti(const TString& conto);
  TRiclassify_cache();
};

void TRiclassify_cache::extract(const TString& conto, TString_array& conti) const
{
  TRecord_array table(conto, LF_PANAPDC);
  for (int r = table.last_row(); r > 0; r = table.pred_row(r))
  {
    const TRectype& row = table.row(r);
    const TBill b(row);
    conti.add(b.string(0x8));
  }
}

TObject* TRiclassify_cache::key2obj(const char* key)
{
  TString_array* k = new TString_array;
  if (key && int(strlen(key)) > _conto_min)
  {
    extract(key, *k);
  }
  else
  {
    TString query = "USE PCONANA";
    if (key && *key)
    {
      query << "\nFROM CODCONTO=" << key;
      query << "\nTO CODCONTO=" << key;
    }
    TISAM_recordset pconana(query);
    for (TRecnotype i = 0; pconana.move_to(i); i++)
    {
      const TString& conto = pconana.get(PCONANA_CODCONTO).as_string();
      extract(conto, *k);
    }
  }
  return k;
}

const TString_array& TRiclassify_cache::conti(const TString& conto)
{
  return *(const TString_array*)objptr(conto);
}

TRiclassify_cache::TRiclassify_cache() : TCache(7) 
{ 
  const TMultilevel_code_info& info = ca_multilevel_code_info(LF_PCONANA);
  _conto_min = info.total_len(-1);  // Lunghezza conti fino al penultimo livello
}


////////////////////////////////////////////////////////
// TSaldi_cache
////////////////////////////////////////////////////////

class TSaldi_cache : private TCache
{
  TEsercizi_contabili _esc;
  TRiclassify_cache _riclass;

protected:
  virtual TObject* key2obj(const char* key);

  bool int_saldo_annuale(const TAnal_bill& bill, int annoini, int annofin, word tipo, TImporto& dare, TImporto& avere) const;
  bool int_saldo_movimenti(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipo, TSaldanal& s) const;

protected:
  bool saldo_annuale(const TAnal_bill& bill, int annoini, int annofin, word tipo, TImporto& dare, TImporto& avere);
  bool saldo_movimenti(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipo, TSaldanal& s);
  bool saldi(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipo, TSaldanal& s);

public:
  const TSaldanal& saldo(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipi = 0x1);
  TSaldi_cache();
};

// Calcolo saldo annuale di un conto reale NON riclassificato
bool TSaldi_cache::int_saldo_annuale(const TAnal_bill& b, int da_anno, int ad_anno, word tipo, 
                                     TImporto& dare, TImporto& avere) const
{
  CHECKD(ad_anno > 0, "Anno saldo finale errato: ", ad_anno);
  
  bool movim = false;
  TString query, select;

  if (b.costo().not_empty())
    select << "(COSTO=='" << b.costo() << "')";
  if (b.commessa().not_empty())
  {
    if (select.not_empty()) select << "&&";
    select << "(COMMESSA=='" << b.commessa() << "')";
  }
  if (b.fase().not_empty())
  {
    if (select.not_empty()) select << "&&";
    select << "(FASE=='" << b.fase() << "')";
  }
  if (b.conto().not_empty() && da_anno != ad_anno)
  {
    if (select.not_empty()) select << "&&";
    select << "(CONTO[1," << b.conto().len() << "]=='" << b.conto() << "')";
  }

  query << "USE SALDANA";
  if (select.not_empty())
    query << " SELECT " << select;
  if (da_anno > 0)
  {
    query << "\nFROM ANNO=" << da_anno;
    query << '\n';
  }

  query << "\nTO ANNO=" << ad_anno;
  query << '\n';

  TISAM_recordset saldini(query);

  for (TRecnotype i = 0; saldini.move_to(i); i++)
  {
    char sez = ' ';
    real imp;
    if (tipo & _saldanal_consuntivo)
    {
      sez = saldini.get(SALDANA_SEZIONE).as_string()[0];
      imp = saldini.get(SALDANA_SALDO).as_real();
    }
    if (tipo & _saldanal_preventivo)
    {
      sez = saldini.get(SALDANA_SEZIONEP).as_string()[0];
      imp = saldini.get(SALDANA_SALDOP).as_real();
    }
    if (tipo & _saldanal_variazione)
    {
      sez = saldini.get(SALDANA_SEZIONEV).as_string()[0];
      imp = saldini.get(SALDANA_SALDOV).as_real();
    }
    if (sez > ' ')
    {
      if (sez == 'D')
        dare += TImporto('D', imp);
      else
        avere += TImporto('A', imp);
      movim = true;
    }
  }

  return movim;
}

bool TSaldi_cache::saldo_annuale(const TAnal_bill& b, int da_anno, int ad_anno, word tipo, 
                                 TImporto& dare, TImporto& avere)
{
  bool movim = false;
  if (ad_anno > 0)
  {
    if (tipo & _saldanal_riclassify)
    {
      // Legge tabella di riclassificazione
      const TString_array& table = _riclass.conti(b.conto());
      if (!table.empty())
      {
        TAnal_bill c(b); // Conto riclassificato
        FOR_EACH_ARRAY_ROW(table, i, row)
        {
          c.set_conto(*row);
          movim |= int_saldo_annuale(c, da_anno, ad_anno, tipo, dare, avere);
        }
      }
    }
    else
      movim = int_saldo_annuale(b, da_anno, ad_anno, tipo, dare, avere);
  }
  return movim;
}

bool TSaldi_cache::int_saldo_movimenti(const TAnal_bill& b, 
                                       const TDate& dal, const TDate& al, 
                                       word tipo, TSaldanal& s) const
{
  TDate dataini;
  if (dal.ok())
  {
    const int annoprec = _esc.date2prevesc(dal);
    if (annoprec > 0)
      dataini = _esc[annoprec].fine()+1L;
  }

  TString query, select;

  if (b.costo().not_empty())
  {
    if (select.not_empty())
      select << "&&";
    select << "(CODCOSTO==\"" << b.costo() << "\")";
  }
  if (b.commessa().not_empty())
  {
    if (select.not_empty())
      select << "&&";
    select << "(CODCMS==\"" << b.commessa() << "\")";
  }
  if (b.fase().not_empty())
  {
    if (select.not_empty())
      select << "&&";
    select << "(CODFASE==\"" << b.fase() << "\")";
  }

  query << "USE RMOVANA KEY 2\n";
  if (select.not_empty())
    query << "SELECT " << select << "\n";

  // Faccio la join solo se mi serve il tipo movimento in testata
  const bool filtra_tipo = (tipo & _saldanal_qualsiasi) != 0 && 
                           (tipo & _saldanal_qualsiasi) != _saldanal_qualsiasi;
  if (filtra_tipo)
    query << "JOIN MOVANA INTO NUMREG==NUMREG\n";

  query << "FROM CODCONTO=" << b.conto();
  if (dataini.ok())
    query << " DATACOMP=" << dataini;
  query << "\n";

  query << "TO CODCONTO=" << b.conto();
  if (al.ok())
    query << " DATACOMP=" << al;
  query << "\n";
  
  TISAM_recordset rmovana(query);

  for (TRecnotype i = 0; rmovana.move_to(i); i++)
  {
    // Controllo il tipo movimento solo se necessario
    if (filtra_tipo)
    {
      const char tipomov = rmovana.get("107.TIPOMOV").as_string()[0];
      int ntipomov = 0;
      if (tipomov == 'P')
        ntipomov = _saldanal_preventivo; else
      if (tipomov == 'V')
        ntipomov = _saldanal_variazione; 
      else
        ntipomov = _saldanal_consuntivo; 
      if ((ntipomov & tipo) == 0)
        continue;
    }

    const TDate data = rmovana.get(RMOVANA_DATACOMP).as_date();
    const TImporto imp(rmovana.get(RMOVANA_SEZIONE).as_string()[0], 
                       rmovana.get(RMOVANA_IMPORTO).as_real());
    if (data >= dal)
    {
      if (imp.sezione() == 'D')
        s._dare += imp;
      else
        s._avere += imp;
      s._movimentato = true;
    }
    else
    {
      s._ini += imp;
    }
  }
  return s._movimentato;
}

bool TSaldi_cache::saldo_movimenti(const TAnal_bill& b, 
                                   const TDate& dal, const TDate& al, 
                                   word tipo, TSaldanal& s)
{
  bool movim = false;
  if (tipo & _saldanal_riclassify)
  {
    // Legge tabella di riclassificazione
    const TString_array& table = _riclass.conti(b.conto());
    if (!table.empty())
    {
      TAnal_bill c(b); // Conto riclassificato
      FOR_EACH_ARRAY_ROW(table, i, row)
      {
        c.set_conto(*row);
        movim |= int_saldo_movimenti(c, dal, al, tipo, s);
      }
    }
  }
  else
    movim = int_saldo_movimenti(b, dal, al, tipo, s);
  return movim;
}

bool TSaldi_cache::saldi(const TAnal_bill& bill, 
                         const TDate& dal, const TDate& al, word tipo, 
                         TSaldanal& s)
{
  // Calcolo i saldi fino all'anno scorso.
  // In assemza di data iniziale mi torna 0
  const int anno_prec = _esc.date2prevesc(dal);
  if (anno_prec > 0)
  {
    TImporto dare, avere;
    saldo_annuale(bill, 0, anno_prec, tipo, dare, avere);
    s._ini = dare;
    s._ini += avere;
  }

  if (tipo & _saldanal_ultima_imm)
  {
    // Calcolo i saldi di quest'anno
    // In assemza di data iniziale somma tutti gli anni (fino al 9999)
    const int anno_ini = _esc.date2esc(dal);
    const int anno_fin = anno_ini > 0 ? anno_ini : 9999;
    s._movimentato = saldo_annuale(bill, anno_ini, anno_fin, tipo, s._dare, s._avere);
  }
  else
  {
    saldo_movimenti(bill, dal, al, tipo, s);
  }
  s._ini.normalize();
  s._fin = s._ini; 
  s._fin += s._dare; 
  s._fin += s._avere;
  s._fin.normalize();

  return s._movimentato;
}

TObject* TSaldi_cache::key2obj(const char* key)
{
  TSaldanal* s = new TSaldanal;

  TToken_string tok(key);
  const TAnal_bill bill(tok.get(0), tok.get(1), tok.get(2), tok.get(3));
  const TDate dal = tok.get(4); // Le get precedenti avvengono in ordine inverso!
  const TDate al = tok.get();
  const int tipo = tok.get_int();
  saldi(bill, dal, al, tipo, *s);                    
  return s;
}

const TSaldanal& TSaldi_cache::saldo(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipi)
{
  TToken_string key;
  key.add(bill.conto(), 0);
  key.add(bill.costo(), 1);
  key.add(bill.commessa(), 2);
  key.add(bill.fase(), 3);
  key.add(dal, 4);
  key.add(al, 5);
  key.add(tipi, 6);
  return *(const TSaldanal*)objptr(key);
}


TSaldi_cache::TSaldi_cache() : TCache(3881)  // Numero primo
{ }

const TSaldanal& ca_saldo(const TAnal_bill& bill, const TDate& dal, const TDate& al, word tipi)
{
  static TSaldi_cache* cache = NULL;
  if (cache == NULL)
    cache = new TSaldi_cache;
  return cache->saldo(bill, dal, al, tipi);
}