Patch level :

Files correlati     :
Ricompilazione Demo : [ ]
Commento            :
Aggiunto suporto per tipi record non compresi nel file .ini


git-svn-id: svn://10.65.10.50/trunk@6945 c028cbd2-c16b-5b4b-a496-9718f37d4682

include/filetext.cpp

@@ -181,10 +181,11 @@ void TFile_text::set_gen_parm(TConfig& config, const TString& section)
     _recordsep = "\r\n";       
   _skiplines = config.get_int("SKIPLINES",section);   // righe iniziali da ignorare
     
-  _typefield =  config.get_int("TYPEFIELD",section);  // Numero del campo tipo (puo' essere -1)
+  _typefield = config.get_int("TYPEFIELD",section);  // Numero del campo tipo (puo' essere -1)
   _fixedlen = _fieldsep <= ' '; // && _recordsep.blank();
-  _typepos = -1; 
+  _typepos = config.get_int("TYPEPOS", section, -1, -1); 
-  _typelen = -1;
+  _typelen = config.get_int("TYPELEN", section, -1, -1); 
+  CHECKD(_typelen <= 16, "Tipo record di lunghezza spropositata: ", _typelen);
 }        
 
 void TFile_text::set_type_parm(TConfig& config, TString& section)
@@ -332,17 +333,24 @@ void TFile_text::set_rec_parm(TConfig& config, const char* section)
     }          
     if (lavoro == "POS")
     {             
-       int pos = atoi(obj);
+       const int pos = atoi(obj);
-       tc.set_position(pos);
+       if (pos >= 0)
-       if (_fixedlen && _typepos < 0 && n == _typefield)
+       {
-          _typepos = pos;
+         tc.set_position(pos);
+         if (_typepos < 0 && n == _typefield)
+            _typepos = pos;
+       }
        continue;
     }
     if (lavoro == "LEN")
     {             
-       int len = atoi(obj);                  
+       const int len = atoi(obj);                  
-       if (tc.length() <= 0 && len >= 0 && tc.length() != len)
+       if (tc.length() <= 0 && len > 0)
-          tc.set_length(len);
+       {
+         tc.set_length(len);
+         if (_typelen < 0 && n == _typefield)
+            _typelen = len;
+       }
        continue;
     }                  
     if (lavoro == "DEC")
@@ -445,11 +453,16 @@ TFile_text::~TFile_text()
 //Legge da file il record text
 int TFile_text::read(TRecord_text& rec)
 {
-  CHECK(_read_file, "Impossibile leggere da un file chiuso.");
+  if (_read_file == NULL)
+    open('r');
 
-  TToken_string buffer(_recordsize), lavoro;
+  TToken_string buffer; 
+  
   if (_recordsize > 0)
   {        
+    if (buffer.size() < _recordsize)
+      buffer.spaces(_recordsize);
+    
     _read_file->read(buffer.get_buffer(), _recordsize); 
     if (!ok_r()) return 1; //non ritorna errore se fine file ed il record e' completo!
   }
@@ -461,12 +474,13 @@ int TFile_text::read(TRecord_text& rec)
       return EOF;
 
     while (c != _recordsep[0])
-    {  
+    { 
       buffer << c;
       c = _read_file->get();
       if (!ok_r()) 
         return EOF; //non ritorna errore se fine file ed il record e' completo! 
     }     
+
     // prendo il resto del separatore  
     int l = _recordsep.len()-1; 
     for (int j = 0; j < l;c = _read_file-> get (), j++);
@@ -481,32 +495,35 @@ int TFile_text::read(TRecord_text& rec)
     rec.set_type(tipo);//istanzio il tipo del record text
     
     TArray& a_tc = tr.tracciati_campo();
-    int items =  a_tc.items();
+    const int items =  a_tc.items();
     buffer.restart();
     for (int i = 0; i < items; i++)
     {
-//      TTracciato_campo& tc = tr.get(i);
+      const char* lavoro = buffer.get();
-      lavoro = buffer.get();
+      if (lavoro == NULL)
+        lavoro = "";
       rec.add(lavoro, i);
     }
   }
   else
   {
-    TString tipo = buffer.mid(_typepos, _typelen);
+    TString16 tipo = buffer.mid(_typepos, _typelen);
     tipo.trim();
     rec.set_type(tipo);//istanzio il tipo del record text
     TTracciato_record* tr = t_rec(tipo); 
-    CHECK(tr,"Tipo di tracciato record non riconosciuto");
+    if (tr != NULL)
-    //ora che ho il tracciato record devo scandire i tracciati campo e caricare il record text
-    TArray& a_tc = tr->tracciati_campo();
-    int items =  a_tc.items();
-    for (int i = 0; i < items; i++)
     {
-      TTracciato_campo& tc = tr->get(i);
+      //ora che ho il tracciato record devo scandire i tracciati campo e caricare il record text
-      int pos = tc.position();
+      const TArray& a_tc = tr->tracciati_campo();
-      int len = tc.length();
+      const int items = a_tc.items();
-      lavoro = buffer.mid(pos, len); 
+      for (int i = 0; i < items; i++)
-      rec.add(lavoro, i);
+      {
+        TTracciato_campo& tc = tr->get(i);
+        const int pos = tc.position();
+        const int len = tc.length();
+        const char* lavoro = buffer.mid(pos, len); 
+        rec.add(lavoro, i);
+      }
     }
   }
   return 0;          
@@ -515,12 +532,13 @@ int TFile_text::read(TRecord_text& rec)
 //Scrive su file il  record_text  (valido anche per header e footer)
 int TFile_text::write(TRecord_text& rec)
 {
-  TString buffer;  
   TString campo;
+  TToken_string buffer; 
+
   const TString& type = rec.type();
   TTracciato_record& tr = *t_rec(type);
   TArray& a_tc = tr.tracciati_campo();
-  int items = rec.items();
+  const int items = rec.items();
   if (_typepos>=0)
     rec.add(type,_typepos);
   if (_fixedlen) // campi a lunghezza fissa
@@ -528,8 +546,7 @@ int TFile_text::write(TRecord_text& rec)
     for (int i = 0; i < items; i++)
     {
       TTracciato_campo& tc = tr.get(i); 
-      campo = rec.row(i);   
+      campo =  format_textfield(tc, rec.row(i));
-      campo =  format_textfield(tc, campo);
       buffer.insert(campo, tc.position());                        
       campo.cut(0);
     }
@@ -539,31 +556,29 @@ int TFile_text::write(TRecord_text& rec)
       // Record a lunghezza var
       *_write_file <<  buffer;                                  
       *_write_file << _recordsep;
-    } else {
+    } 
+    else 
+    {
       // Record a lunghezza fissa
       buffer.rpad(_recordsize);
       buffer.cut(_recordsize);
       *_write_file <<  buffer;                                  
     }
-      if (!ok_w()) return 1;
+    if (!ok_w()) return 1;
-      buffer.cut(0);
   }    
   else
   {
-    TToken_string ts(buffer, _fieldsep);
+    buffer.separator(_fieldsep);
     for (int i = 0; i < items; i++)
     {
       TTracciato_campo& tc = tr.get(i); 
-      campo = rec.row(i);   
+      campo =  format_textfield(tc, rec.row(i));
-      campo =  format_textfield(tc, campo);
+      buffer.add(campo);
-      ts.add(campo, i);
-      campo.cut(0);
     }
     CHECK(_write_file, "Impossibile scrivere su un file chiuso.");
-    *_write_file << ts;
+    *_write_file << buffer;
     *_write_file << _recordsep;
     if (!ok_w()) return 1;   
-    ts.cut(0);
   }  
   return 0;
 }
@@ -728,8 +743,9 @@ int TFile_text::_autosave(TRelation& rel, const TRecord_text& rec, TTracciato_re
     if (err == _isdupkey || err ==_isreinsert)
       err = rel.rewrite();     
     return err;       
-  } else
+  }
-    return NOERR;
+ 
+  return NOERR;
 } 
 
 //Scarica dal record_text il campo alla posizione <ncampo>
@@ -755,11 +771,18 @@ const TString& TFile_text::get_field(const TRecord_text& rec, const char* name)
 //Carica nel record_text il campo alla posizione <ncampo> con il valore <val> già formattato  
 void TFile_text::add_field(TRecord_text& rec, const int ncampo, const char* val)
 {
-   TTracciato_record& tr = *t_rec(rec.type());
+  TTracciato_record& tr = *t_rec(rec.type());
-   TTracciato_campo& tc = tr.get(ncampo);
+  TTracciato_campo& tc = tr.get(ncampo);
-   TString valore = val; 
+  rec.add(val, ncampo);    
-   //valore =format_textfield(tc, valore);
+}    
-   rec.add(valore, ncampo);    
+
+//Carica nel record_text il campo <name> con il valore <val> già formattato  
+void TFile_text::add_field(TRecord_text& rec, const char* name, const char* val)
+{
+  TTracciato_record& tr = *t_rec(rec.type());
+  int ncampo = tr.get_pos(name);
+  CHECKS(ncampo >= 0, "Campo inesistente ", name);
+  rec.add(val, ncampo);
 }    
 
 //Formatta la data in base al tracciato 

include/filetext.h

@@ -116,20 +116,24 @@ public:
 ////////////////////////////////////////////////////////////////////////////                       
 class TRecord_text : public TObject
 {                                                          
-  TString _type;//tipo del record
+  TString16 _type;       //tipo del record
-  TString_array _array;//array che contiene i valori dei campi 
+  TString_array _array;  //array che contiene i valori dei campi 
+
 public:
-  TRecord_text() {}
-  TRecord_text(const TString& type):   _type(type) {}
-  virtual ~TRecord_text(){}
   const TString& type() const {return _type;} 
   void set_type(const TString& type) {_type = type;} 
   const TString& row(int pos) const;//usare la get!!!
   TString& row(int pos);
   const TString& get(int pos) const {return row(pos);}//ritorna il campo dell'array della posizione <pos>     
   void add(const TString& c, int pos = -1);//scrive il campo <c> nell'array  alla posizione <pos> 
+  
   const int items() const {return _array.items();}//ritorna il numero di elementi dell'array
-  virtual bool destroy(int index = -1, bool pack = FALSE) {return _array.destroy(index, pack);}
+  virtual bool destroy(int index = -1, bool pack = FALSE) 
+  { return _array.destroy(index, pack); }
+
+  TRecord_text() { }
+  TRecord_text(const TString& type) : _type(type) { }
+  virtual ~TRecord_text(){}
 };
 ///////////////////////////////// TFile_text //////////////////////////////////////
 // Classe per la definizione di un file di testo  capace di leggersi e scriversi,//
@@ -186,8 +190,6 @@ protected:
   virtual bool pre_writerel(TRelation& rel,const TRecord_text& rec) {return TRUE;}
   virtual bool can_write(TRecord_text&, TRelation&) {return TRUE;}
 public:        
-  TFile_text(const char* file_name, const char* config_name);
-  virtual ~TFile_text();
   ifstream* read_file() {return _read_file;}
   ofstream* write_file() {return _write_file;}
   void set_gen_parm(TConfig& config, const TString& section);//scarica i parametri generali dal file di configurazione   
@@ -241,14 +243,19 @@ public:
   int autosave(const TRecord_text& rec, int mainfile=0);
   //caricamento automatico della relazione definita nel tracciato dal record_text 
   int autosave(int mainfile);
-  int read(TRecord_text & rec);//legge da  file di testo il record_text 
+  int read(TRecord_text& rec);//legge da  file di testo il record_text 
   int read() {return read(*_current);}//legge da file di testo il record_text corrente
   //carica nel record_text il campo alla posizione <ncampo> con il valore <val> già formattato
   void add_field(TRecord_text& rec, const int ncampo, const char* val);
+  //carica nel record_text il campo <name> con il valore <val> già formattato
+  void add_field(TRecord_text& rec, const char* name, const char* val);
   //scarica dal record_text il campo alla posizione <ncampo>
   const TString& get_field(const TRecord_text& rec, int ncampo);
   //scarica dal record_text il campo di nome <name>
   const TString& get_field(const TRecord_text& rec, const char* name);
+
+  TFile_text(const char* file_name, const char* config_name);
+  virtual ~TFile_text();
 };                  
 
 #endif //__FILETEXT_H