---

dataio.h

Go to the documentation of this file.

// dataio 0.5 (beta) - Copyright (C) 2001, by Sadao Massago              //
// file: dataio.h (dataio header file)                                   //
// requires: stringutil.h                                                //
// ----------------------------------------------------------------------//
// The dataio library and related files is licenced under the term of    //
// GNU Lesser General Public License version 2.1 or latter               //
// (see lesser.txt for detail).                                          //
// For information over GNU or GNU compatible license, visit the site    //
// http://www.gnu.org.                                                   //

// javadoc style documentation in way to generate class documentation   //
// using GNU GPL licensed doxygen utility. For doxygen, see the         //
// http://www.doxygen.org                                               //

// TO DEVELOPER: Caution for using template class.
// The inline methods will not speciallyzed correctly
// (if split into two files, each of one generate one and can not link it)
// Thus, all of methos that will specialize, use as non inline version
// (define outside of class) independent of their code size (one line, for example)
// !!!

#ifndef  _DATAIO_H_
// #ifdef __cplusplus
#define _DATAIO_H_


#ifndef DOXYGEN_SHOULD_SKIP_THIS // doxygen skip this...

// #define _DEBUG_

#ifdef _DEBUG_ // _DEBUG_ activate debugging mod for this...
   #define _DATAIODEBUG_
#endif

// #define _DATAIONOMESSAGE_ // if error occur, do not emit error message 
// #define _DATAIONOTHROW_ // (don't throw exception)

// #ifdef _DATAIODEBUG_ // in debug mode, activate message
//   #undef _DATAIONOMESSAGE_ // if error occur, do not emit error message 
// #endif

#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS // doxygen skip this...

// defining group for dataio (for doxygen)
// need only if want to list in module section.
// doxygen bug???: it make the template class member listed as public functions???
// there are member itemtostring() and stringtoitem() of _dataiorec
// template class

// for dxygen usage only (skip or not some part of code)
// use: PREDEFINED = DOXYGEN_SHOULD_SKIP_THIS in doxygen config file

// starting group (for doxygen)

#define _DATAIODEFAULTCOLUMNSEPARATOR '\t'
#define  _DATAIODEFAULTAUTOLINESEPARATOR '\0'

#define _DATAIODEFAULTLINESEPARATOR  _DATAIODEFAULTAUTOLINESEPARATOR
#define _DATAIODEFAULTATTRIBSEPARATOR '\0'

#define _DATAIODEFAULTDECIMAL         '.'

#define _DATAIODEFAULTIGNORECASE      false

#define _DATAIODEFAULTCOMMENTLINE     "//"

#define _DATAIODEFAULTCOMMENTOPEN     "/*" 
#define _DATAIODEFAULTCOMMENTCLOSE    "*/"

#define _DATAIODEFAULTSTDCOMMENTOPEN     "/*" 
#define _DATAIODEFAULTSTDCOMMENTCLOSE    "*/"

#define _DATAIODEFAULTLINEWRAP     ""
#define _DATAIODEFAULTMAXCOLUMNONLINE  (~0U)

#define _DATAIODEFAULTCOLUMNORIENTED  false

#define _DATAIODEFAULTISTABLE         false

#define _DATAIODEFAULTEMPTYISVALID    true

#define _DATAIODEFAULTEXTENDEDMODE    true
// / default value of mapflagstomember flag (the flag is applied inside their membes)
// #define _DATAIODEFAULTMAPFLAGSTOMEMBER    true
// / default value of includemapflagstomemberflag parameter in the 
// / calling of mapflagstomember()
// #define _DATAIODEFAULTINCLUDEMAPFLAGSTOMEMBERFLAG true
#define _DATAIODEFAULTVALIDATEALL    true

#define  _DATAIODEFAULTCLEAREMPTYTAIL true

#define _DATAIODEFAULTSTRINGDELIMITER    '\"'

#define _DATAIODEFAULTSCAPECHAR    '\0'

#define _DATAIODEFAULTTHROWEXCEPTION   false

#define _DATAIODEFAULTPRINTERROR   true


#define _DATAIODEFAULTCOLLECTNAMES  true

#define _DATAIODEFAULTPARSEALLINPUTSTRING false

#define _DATAIODEFAULTSECTIONNAMEOPEN '\0' /* '[' */

#define _DATAIODEFAULTSECTIONNAMECLOSE '\0' /* ']' */

#define _DATAIODEFAULTSTDSECTIONNAMEOPEN '['

#define _DATAIODEFAULTSTDSECTIONNAMECLOSE ']'

#define _DATAIODEFAULTREVERSEBYTEORDER false

// for boolean recognition
#define _DATAIODEFAULTYESLIST {"true", "on", "yes", 0} // null terminated list
#define _DATAIODEFAULTNOLIST {"false", "off", "no", 0} // null terminated list
#define _DATAIODEFAULTYESVALUE "yes"
#define _DATAIODEFAULTNOVALUE "no"


// For developer (caution):
// will not use inline methods (defined inside of class, or specified by inline)
// for specialized methods (define special handle for some T)
// it cause linking problem for multiple file modules
// it's can not find symbol (it defined only on one file)
// ir duplicate symbol (if defined on more one files)
// Does not know how to solve this problem, without using non inline versions.
// Thus, all method that pretend specialize in future, use
// non inline version.
//
// In this module, several small methods of _dataiorec
// such as ignorecase, decimal, itentostring, stringtoitem
// are  defined as non inline
// because use some specilization for dataio class:
// Do not try to define theses (and other specialized method)
// as inline version!!

// #define MAXUINT ((unsigned) ~0)

#include <string>
#include <iostream>
#include <strstream>
#include <vector>
#include <errno.h> // for C routine error handle

// to use parsestring()
// in debug mode, use putline too??
#include "stringutil.h" 


// dataio class
// forward definition
   class dataio;

   class _dataiorecbase {
   
   // Atributes and member of this class does not documentes
   // to doxygen skip this for documentation
   #ifndef DOXYGEN_SHOULD_SKIP_THIS
   protected:
      void *var; // used by dataio
      unsigned dim;
      unsigned long *size1, *size2, *strsize;
      vector <vector <string> > datalist; // used by getvalue
      vector <string> commentlist; // item comment list
      bool valuesetted; // true if value is setted
      // it will deleted, if change setvalue.
      // bool columnoriented; // used only by dataio
      // dataio that include this
      dataio *base;
      // char decimalchar; // used by _dataiorec members: stringtoitem and itemtostring
      // char stringdelimiterchar; // used by _dataiorec members: stringtoitem and itemtostring
      // bool emptyisvaliddata; // used by _dataiorec members: stringtoitem and itemtostring
      string name;
      // to check if is dataio member
      // used only by dataio to detect if the member is dataio type
      // if it is true, will overrride several parameter settings, as
      // decimal, ignorecase, commentopen, commentclose, etc.
      // used only to make prety print of sectioned data
      // mixed by non sectioned data
      bool isdataio;
      // long int read/writer to read/write size of vector
      static bool readsize(istream &is, unsigned long int &n, bool reverseorder);
      static void writesize(ostream &os, unsigned long int n, bool reverseorder);
      // used by setvalue/read
      virtual void clearitemvalue(){}
      virtual void addrowtoitemvalue(){}
      // used by setvalue
      virtual bool addtoitemvalue(string &s){return false;}
      // used by read
      virtual bool readtoitemvalue(istream &is){return false;}
      // used to getvalue/write
      virtual unsigned long getitemrownumber(){return 1;}
      virtual unsigned long getitemlistsize(unsigned long i) {return 1;}
      // used by getvalue
      virtual void getstringvalue(string &s, unsigned long i, unsigned long j){}
      // used by write
      virtual void writeitemvalue(ostream &os, unsigned long i, unsigned long j){}
   public:
      void setvalue(vector <vector <string> > &valuelist);
      // {  blockcount++;}
      vector <vector <string> > &getvalue(bool includecomment);
      // {    return datalist;    }
      // binary input/output
      istream &read(istream &is);
      ostream &write(ostream &os);
      unsigned blockcount; // to count number of inputed block
      // multiple block data: prepare next output block
      // only for named data
      // virtual void startinblock(unsigned i){return true;}  // used only for dataio
      virtual void startinblock(unsigned i);
      // used only for dataio
      // virtual bool nextinblock(){return true;}  // used only for dataio
      // method for data validator calling.
      void validate();  // used only for dataio
      // method for multi block out put. It will implemented
      // to make adjust in end of readding.
      // For exaple, will initialize unread variable, or make data range cheking...
      // n is number of readded block
      virtual bool startoutblock(unsigned i);
      //{ return (i==0);}
      // used only by dataio to detect if the member is dataio type
      // if it is true, will overrride several parameter settings, as
      // decimal, ignorecase, commentopen, commentclose, etc.
      // used only to make prety print of sectioned data
      // ixed by non sectioned data
   

      // empty member
      _dataiorecbase(){
         dim = 0; base = 0; var = 0; size1 = size2 = strsize = 0;
         valuesetted = isdataio = false; blockcount = 0;
      } 

      // dataio member  
      _dataiorecbase(dataio *_base, string const &_name, dataio *_var){
         dim = 0;  base = _base; name = _name; var = _var; 
         size1 = size2 = strsize = 0; blockcount = 0;
         valuesetted = false;
         isdataio = true;
      } 

      // 0 dimensional member
      _dataiorecbase(dataio *_base, string const &_name, void * _var, unsigned long *_strsize){
         dim = 0;  base = _base; name = _name; var = _var; 
         size1 = size2 = 0; strsize = _strsize;
         valuesetted = isdataio = false; blockcount = 0;
      } 

      // 1 dimensional member
      _dataiorecbase(dataio *_base, string const &_name, void * _var, unsigned long *_size1, unsigned long *_strsize){
         dim = 1; base = _base; name = _name; var = _var; 
         size1 = _size1;
         size2 = 0; strsize = _strsize;
         valuesetted = isdataio = false; blockcount = 0;
      } 

      // 2 dimensional member
      _dataiorecbase(dataio *_base, string const &_name, void * _var, unsigned long *_size1, 
                             unsigned long *_size2, unsigned long *_strsize){
         dim = 2; base = _base; name = _name; var = _var; 
         size1 = _size1;
         size2 = _size2; strsize = _strsize;
         valuesetted = isdataio = false; blockcount = 0;
      } 

      // empty destructor
      virtual ~_dataiorecbase(){
      }
      // friend class
      friend dataio;
      // to acess the name
      friend istream &operator>>(istream &is, dataio &data);
      friend ostream &operator<<(ostream &os, dataio &data);
   
   // to doxygen skip this for documentation
   #endif //#ifndef DOXYGEN_SHOULD_SKIP_THIS
   }; // _dataiorecbase

   template <class T>
   class _dataiorec : public _dataiorecbase {
   // most of atributes and member of this class does not documentes
   // to doxygen skip this for documentation
   #ifndef DOXYGEN_SHOULD_SKIP_THIS
      // used by setvalue/read
      void clearitemvalue()
      {if(dim == 1) ((vector <T> *)var)->clear();
       else if(dim == 2) ((vector <vector <T> > *)var)->clear(); }
      void addrowtoitemvalue()
      { if(dim == 2) ((vector <vector <T> >*)var)->push_back(vector <T>());}
      bool addtoitemvalue(string &s)
      {  bool status;
         T itemvalue; 
         if(dim ==0) {
            #ifdef _DATAIODEBUG_
                cout << "addtoitemvalue:value = ";
                cout << *(T *)var << endl;
            #endif
            status = stringtoitem(s, *((T *)var));
         }
         else if(dim == 1) {
            status = stringtoitem(s, itemvalue);
            ((vector <T>*)var)->push_back(itemvalue);       
         } 
         else {
           status = stringtoitem(s, itemvalue);  
           (*(vector <vector <T> >*)var)[((vector <vector <T> >*)var)->size()-1].push_back(itemvalue);      
        }
        return status;
      }

      // used by read
      bool readtoitemvalue(istream &is)
      {  bool status;
         T itemvalue; 
         if(dim ==0)
            status = readitem(is, *(T *)var);
         else if(dim == 1) {
            status = readitem(is, itemvalue);
            ((vector <T>*)var)->push_back(itemvalue);       
         } 
         else {
           status = readitem(is, itemvalue);  
           (*(vector <vector <T> >*)var)[((vector <vector <T> >*)var)->size()-1].push_back(itemvalue);      
        }
        return status;
      }

      // used by getvalue/write
      unsigned long getitemrownumber()
      {   // if(dim == 1)
          //   return ((vector <T> *)var)->size();
          // else 
          if(dim == 2)
             return ((vector <vector <T> >*)var)->size();
          return 1;
      }
      unsigned long getitemlistsize(unsigned long i)
      {
          if(dim == 1)
               return ((vector <T> *)var)->size();
          else if((dim == 2) && (i < (*(vector <vector <T> >*)var).size()))
               return (*(vector <vector <T> >*)var)[i].size();
          return 1; 
      }
      // used by getvalue
      void getstringvalue(string &s, unsigned long i, unsigned long j)
      {
          if(dim == 0) itemtostring(*(T *)var, s);
          else if((dim == 1) && (i < (*(vector <T> *)var).size()))
               itemtostring((*(vector <T> *)var)[i], s);
          else if((dim == 2) && (i < (*(vector <vector <T> >*)var).size())
                             && (j < (*(vector <vector <T> >*)var)[i].size()))
               itemtostring((*(vector <vector <T> >*)var)[i][j], s);
          else s.erase();          
      }
      // used by write
      void writeitemvalue(ostream &os, unsigned long i, unsigned long j)
      {
          if(dim == 0) writeitem(os, *(T *)var);
          else if((dim == 1) && (i < (*(vector <T> *)var).size()))
               writeitem(os, (*(vector <T> *)var)[i]);
          else if((dim == 2) && (i < (*(vector <vector <T> >*)var).size())
                             && (j < (*(vector <vector <T> >*)var)[i].size()))
               writeitem(os, (*(vector <vector <T> >*)var)[i][j]);
      }
      // virtual bool additemvalue(string &s)
      // {return stringtoitem(s, *(T *)item);}
      // virtual void itemvaluetostring(void *item, string &s)
      // {itemtostring(*(T *)item, s);}
      
   public:
      // void startinblock(unsigned i);
      // void validate();
      // bool startoutblock(unsigned i);

      _dataiorec(dataio *_base, string const &_name, dataio *item) :
             _dataiorecbase(_base, _name, item){}
      _dataiorec(dataio *_base, string const &_name, T *item, unsigned long *_strsize) : 
             _dataiorecbase(_base, _name, item, _strsize){}
      _dataiorec(dataio *_base, string const &_name, vector <T> *item, 
             unsigned long *m, unsigned long *_strsize) :
             _dataiorecbase(_base, _name, item, m, _strsize){}
      _dataiorec(dataio *_base, string const &_name, vector <vector <T> > *item, 
             unsigned long *m, unsigned long *n, unsigned long *_strsize) :
             _dataiorecbase(_base, _name, item, m, n, _strsize){}

      // void setvalue(vector <vector <string> > &item);
      // vector <vector <string> > &getvalue(bool includecomment);
   
      // istream &read(istream &is);
      // ostream &write(ostream &os);
      // Atributes and member of this class does not documentes
      // to doxygen skip this for documentation
   #endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
   
   public: // arleady public, but for doxygen... (for doxygen, above public is hidden)
      // stringtoitem/itemtostring methods is virtual in way to add your own
      // if error occur, return the false
      // in way to obtain finally status
      // 
      bool stringtoitem(string &s, T &item);
      void itemtostring(T const &item, string &s);
      bool readitem(istream &is, T &item);
      void writeitem(ostream &os, T const &item);

      // friend dataio;
   }; // _dataiorec

   class dataio {
   private:
      vector <vector <string> > datalist; // used by getvalue()
      vector <string>commentlist; // comment string list.]

      vector <_dataiorecbase *> unnamed;
      vector <_dataiorecbase *> named;  
      vector <bool> isnamedvar; // used by binary input/output to determine order 
      // fstream f;
      // store names refered in the databese 
      vector <string> referednameslist;
      // store names that do not refered in the databese 
      // used by unreferednames()
      vector <string> unreferednameslist;
   
      // bool commentopened;
      bool casesensive;
      char decimalchar;
      // char stringdelimiterchar;

      // true if the value is setted correctly
      bool valuesetted;
      // Comment line marker.
      // Default is _DATAIODEFAULTCOMMENTLINE
      string commentlinemark; 
      // Comment block start marker. Ignore until commentclose occur. 
      // Default is _DATAIODEFAULTCOMMENTOPEN
      // \sa _DATAIODEFAULTCOMMENTOPEN, commentclose, commentline     
      string commentopenmark; 
      // Comment block endding marker. End the comment started by commentopen.
      // Default is _DATAIODEFAULTCOMMENTCLOSE
      // \sa _DATAIODEFAULTCOMMENTCLOSE, commentopen, commentline
      string commentclosemark;    
      // line wrap marker;
      string linewrapmark; 
      // if this flag is true, consider empty value as valid value
      // inside of several stringtoitem() conversion
      // Default is _DATAIODEFAULTEMPTYISVALID
      bool emptyisvaliddata;
      // if this flag is true, all item string is parsed in the 
      // input process. atenpt to evit double parsing
      // in the string to item...
      // bool parseallitemstring;
      // if this flag, collect refered names in the set value stage 
      // (inclusive in the dataio classes that is not directly loaded)
      bool collectreferednames;
      // validate unrefered member ??  
      bool validateunreferedmember;

      // if this flag is true, throw exception on error
      // default value is _DATAIOTHROWEXCEPTION
      // \sa errormessage,  _DATAIOTHROWEXCEPTION
      bool throwonerror;
      // if this flag is true, coutput error message on error
      // default value is _DATAIODEFAULTPRINTERROR
      // \sa throwexception, _DATAIODEFAULTPRINTERROR
      bool printerrormessage;

      // map recomended flags that member need to same, in way to perform i/o.
      // the required flags is not copied, because it will setted during i/o
      void maprecomendedflagsto(dataio &dest);
      // map minimal required flags that member need to same, in way to perform i/o.
      void maprequiredflagsto(dataio &dest);

      // map minimun required flags to their members. This flags are:
      // used by delimiterrecomended (for correct output):
      //    columnseparator, lineseparator, attribseparator,
      //   commentopenmark, commentclosemark, commentline, stringdelimiter, linewrap,
      //  
      void maprecomendedflagstomember();
      void maprequiredflagstomember();
      // CAUTION: no type checking!!
      // use isdataio() to check validate and check the i range
      dataio * unnamedmember(unsigned i) {return (dataio *)(unnamed[i]->var);}
      dataio * namedmember(unsigned i) {return (dataio *)(named[i]->var);}
   public:
      void addcomment(string const &rem) {addcommenttolist(rem, commentlist);}
      void clearcomment(bool includemember=false);
      vector <string> &comment() {return commentlist;}
       

      bool addcomment(string const &name, string const &rem);
      bool additemcomment(void *item, string const &rem);
      void clearcomment(string const &name, bool includemember=false);
      void clearitemcomment(void *item, bool includemember=false);
      void clearitemcomment(bool includemember=false);
      vector <string> &comment(string const &name);
      vector <string> &itemcomment(void *item);

      // comment markers
      string &commentline() {return commentlinemark;}
      string &commentline(string const &com) 
      {return parsestring(commentlinemark = com, stringdelimiter, scapechar);} 
      string &linewrap() { return linewrapmark;}; 
      string &linewrap(string const &wrap)
      {return parsestring(linewrapmark=wrap, stringdelimiter, scapechar);}
      unsigned maxcolumnonline;
      bool istable; 
   
      char sectionnameopen;
      char sectionnameclose; 
      void disablesection()
      { sectionnameopen = '\0';
        sectionnameclose = '\0';
      }
      void enablestdsection()
      { sectionnameopen = _DATAIODEFAULTSTDSECTIONNAMEOPEN;
        sectionnameclose = _DATAIODEFAULTSTDSECTIONNAMECLOSE;
      }

      bool columnoriented; 
      char columnseparator;
      char lineseparator;
      char attribseparator;
      bool extendedmode;
      bool clearemptytail;
      bool parseallinputstring;

      bool throwexception() {
        return throwonerror; }
      bool throwexception(bool dec, bool includemember=true);
      bool printerror() {
        return printerrormessage; }
      bool printerror(bool dec, bool includemember=true);

      bool emptyisvalid(){
         return emptyisvaliddata;}
      bool emptyisvalid(bool flag, bool includemember=true);

      bool ignorecase() { 
         return !casesensive;}  



      bool ignorecase(bool status, bool includemember=true);
      char decimal() { 
         return decimalchar;}  



      char decimal(char dec, bool includemember=true);

      char stringdelimiter;

      char scapechar;

      bool reversebyteorder;

      bool validateall() { 
         return validateunreferedmember;}  



      bool validateall(bool status, bool includemember=true);
   
      string &commentopen() { 
         return commentopenmark;} 


      // */ disapar... how to insert it on document file??
      string &commentopen(string const &s) {
         return parsestring(commentopenmark = s, stringdelimiter, scapechar);} //(s, mapthisflagstomember); }
   
      string &commentclose() { 
         return commentclosemark;} 



      string &commentclose(string const &s) {
         return parsestring(commentclosemark = s, stringdelimiter, scapechar);} //(s, mapthisflagstomember); }
      // string &commentclose(string const &s, bool includemember);
   
      void disablecommentblock()
      { commentopen("");
        commentclose("");
      }
      void enablestdcommentblock()
      { commentopen(_DATAIODEFAULTSTDCOMMENTOPEN);
        commentclose(_DATAIODEFAULTSTDCOMMENTCLOSE);
      }
      // check if the values is correctly setted (return false, if not refered in database)
      bool setted() { 
         return valuesetted;}  
      bool setted(string const &name); 
      // /< \sa refered, itemsetted, itemrefered 
      bool itemsetted(void *item); 
      // /< \sa refered, setted, itemsetted 

      // / CAUTION: name of this methods will change!
      // / \return the flag for name collector.
      bool collectnames() { 
         return collectreferednames;} 
      bool collectnames(bool flag, bool includemember=true);
      bool refered(string const &name){  
         string key = name;
         return keysearch(key, referednameslist) != referednameslist.size();} 
      bool itemrefered(void *item) {  
         return (finditem(item, unnamed) != unnamed.size()) || (finditem(item, named) != named.size()); }

      vector <string> &referednames(){
         return referednameslist;} 
      vector <string> &unreferednames(); 
   
      void add(string const &name, dataio *item)
      {  named.push_back(new _dataiorec <dataio>(this, name, item)); 
         // named[named.size()-1]->base = this;
         parsestring(named[named.size()-1]->name, stringdelimiter, scapechar);
         #ifdef _DATAIODEBUG_
           cerr << "dataio::add(): adding named dataio item: " 
                << named[named.size()-1]->name << endl;
         #endif
         // named[named.size()-1]->isdataio = true;
         item->ignorecase(!casesensive); 
         item->decimal(decimalchar);
         item->emptyisvalid(emptyisvaliddata); 
         item->collectnames(collectreferednames); 
         isnamedvar.push_back(true);
      }
      void add(dataio *item)
      {  unnamed.push_back(new _dataiorec <dataio>(this, "", item)); 
         // unnamed[unnamed.size()-1]->base = this;
         // unnamed[unnamed.size()-1]->isdataio = true;
         #ifdef _DATAIODEBUG_
           cerr << "dataio:add(): adding unnamed dataio item\n";
         #endif
         item->ignorecase(!casesensive);  
         item->decimal(decimalchar);          
         item->emptyisvalid(emptyisvaliddata); 
         item->collectnames(collectreferednames); 
         isnamedvar.push_back(false);
      }

      template <class T>
      void add(string const &name, T *item)
      {  named.push_back(new _dataiorec<T>(this, name, item, (unsigned long *)0)); 
         // named[named.size()-1]->base = this;
         parsestring(named[named.size()-1]->name, stringdelimiter, scapechar);
         #ifdef _DATAIODEBUG_
           cerr << "dataio::add(): adding named template item:"
                << named[named.size()-1]->name << endl;
         #endif         

         isnamedvar.push_back(true);
      }
      template <class T>
      void add(T *item)
      {  unnamed.push_back(new _dataiorec <T>(this, "", item, (unsigned long *)0)); 
         #ifdef _DATAIODEBUG_
           cerr << "dataio::add(): adding unnamed template item\n";
         #endif         // unnamed[unnamed.size()-1]->base = this;
         isnamedvar.push_back(false);
      }
      // one dimensional
      template <class T>
      void add(string const &name, vector <T> *item)
      {  named.push_back(new _dataiorec <T>(this, name, item, (unsigned long *)0, (unsigned long *)0)); 
         // named[named.size()-1]->base = this;
         parsestring(named[named.size()-1]->name, stringdelimiter, scapechar);
         isnamedvar.push_back(true);
      }
      template <class T>
      void add(vector <T> *item)
      {  unnamed.push_back(new _dataiorec <T>(this, "", item, (unsigned long *)0, (unsigned long *)0)); 
         // unnamed[unnamed.size()-1]->base = this;
         isnamedvar.push_back(false);
      }
      // 2 dimensional
      template <class T>
      void add(string const &name, vector <vector <T> > *item)
      {  named.push_back(new _dataiorec <T>(this, name, item, (unsigned long *)0, (unsigned long *)0, (unsigned long *)0)); 
         // named[named.size()-1]->base = this;
         parsestring(named[named.size()-1]->name, stringdelimiter, scapechar);
         isnamedvar.push_back(true);
      }
      template <class T>
      void add(vector < vector <T> > *item)
      {  unnamed.push_back(new _dataiorec <T>(this, "", item, (unsigned long *)0, (unsigned long *)0, (unsigned long *)0)); 
         // unnamed[unnamed.size()-1]->base = this;
         isnamedvar.push_back(false);
      }

      // for fixed size data type
      // The named and unnamed type is treated separatelly (using different names for 
      // adding methods, to solve conflict).
      template <class T>
      void addnamed(string const &name, T *item, unsigned long &strsize=*(unsigned long *)0)
      {  named.push_back(new _dataiorec<T>(this, name, item, &strsize)); 
         // named[named.size()-1]->base = this;
         parsestring(named[named.size()-1]->name, stringdelimiter, scapechar);
         isnamedvar.push_back(true);
      }
      template <class T>
      void addunnamed(T *item, unsigned long &strsize=*(unsigned long *)0)
      {  unnamed.push_back(new _dataiorec <T>(this, "", item, &strsize)); 
         // unnamed[unnamed.size()-1]->base = this;
         isnamedvar.push_back(false);
      }
      // one dimensional
      template <class T>
      void addnamed(string const &name, vector <T> *item, unsigned long &m = *(unsigned long *)0, 
           unsigned long &strsize=*(unsigned long *)0)
      {  named.push_back(new _dataiorec <T>(this, name, item, &m, &strsize)); 
         // named[named.size()-1]->base = this;
         parsestring(named[named.size()-1]->name, stringdelimiter, scapechar);
         isnamedvar.push_back(true);
      }
      // one dimensional
      template <class T>
      void addunnamed(vector <T> *item, unsigned long &m=*(unsigned long *)0, 
             unsigned long &strsize=*(unsigned long *)0)
      {  unnamed.push_back(new _dataiorec <T>(this, "", item, &m, &strsize)); 
         // unnamed[unnamed.size()-1]->base = this;
         isnamedvar.push_back(false);
      }
      template <class T>
      void addnamed(string const &name, vector <vector <T> > *item, unsigned long &m=*(unsigned long *)0,
           unsigned long &n=*(unsigned long *)0, unsigned long &strsize=*(unsigned long *)0)
      {  named.push_back(new _dataiorec <T>(this, name, item, &m, &n, &strsize)); 
         // named[named.size()-1]->base = this;
         parsestring(named[named.size()-1]->name, stringdelimiter, scapechar);
         isnamedvar.push_back(true);
      }
      template <class T>
      void addunnamed(vector < vector <T> > *item, unsigned long &m=0, unsigned long &n=*(unsigned long *)0,
           unsigned long strsize=*(unsigned long *)0)
      {  unnamed.push_back(new _dataiorec <T>(this, "", item, &m, &n, &strsize)); 
         // unnamed[unnamed.size()-1]->base = this;
         isnamedvar.push_back(false);
      }

   // protected:
   private:
      // find item on the (un)named variable list
      unsigned finditem(void const *item, vector<_dataiorecbase *> &list);
      // find name index
      unsigned findname(string const &key);
      // find key on string list
      unsigned keysearch(string const &key, vector<string> &list);
      // find name and add to refered name list
      unsigned findrefername(string const &key);
      bool unnamedsetted();
      bool namedsetted();
   
      // add comment to comment list
      void addcommenttolist(string const &rem, vector <string> &remlist);
      // get comment list as vector <string>, delimiting each item by comment markers
      // used by gettablevalue() and getvalue()
      vector <string> &dataio::commentlisttoblockmode(vector <string> &rem, vector<string> &remlist);

      // get the line with comment, used by getdataline
      istream &getlinewithcomment(istream &f, string &datalinelist);
      // delete the line wrap marker. return false if not found on end of line
      // Do not call this, if linewrap is inactive
      // used by getdataline()
      bool deletelinewrapmarker(string &line);
      // delete the section marker. return false if not section mark, 
      // or section mark is inactive
      // used by operator>>()
      bool deletesectionnamemarker(string &s);

      // return true if section like name (do not apply parsestring inside)
      // for operator<<()
      bool sectionnamelike(string const &s);
      // get one line of data as string
      // istream &getdatatextline(istream &f, string &line);
      // get one line of data and break into list
      istream &getdataline(istream &f, vector <string> &datalinelist);
   
      // read table or column oriente data
      // required by
      //  friend istream &operator>>(istream &is, dataio &data);
      istream &readtableorcolumnoriented(istream &is);
      // return true if s need to delimited.
      // used by output
      bool delimiterrecomended(string const &s);
      // write table or column oriente data
      // required by
      //  friend ostream &operator<<(ostream &os, dataio &data);
      ostream &writetableorcolumnoriented(ostream &os);
      // write comment
      ostream &writecomment(ostream &os, vector <string> const &rem);
      // write line separator in apropriate way
      ostream &writelineseparator(ostream &os);
      // getvalue when is table
      vector <vector <string> > &gettablevalue(bool includecomment);

      // read/write buffer 
      // read buffer. return number of bytes readed
      // if reverse byte order is active and eof is found before end input,
      // the data is on right of buffer (end to first)
      unsigned long dataio::readbuffer(istream &is, unsigned char *buff, unsigned long n);
      // write buffer. Return none
      void dataio::writebuffer(ostream &os, unsigned char *buff, unsigned long n);
       
       // clear only the member input status
       // will analise way to clear it?
       void clearmemberinputstatus();
       // set valuesetted as false and clear referednameslist
       // clear input status of member and this
       void clearinputstatus(bool includemember=true);
       // validate the current class. If validateunrefered is true,
       // validate unrefered members too.
       void validatethis(unsigned n);
   public:
      //  set/get value
      // void setvalue(vector <vector <string> > &item, bool refernames = false);
      void setvalue(vector <vector <string> > &item);
      vector <vector <string> > &getvalue(bool includecomment=false);
      friend istream &operator>>(istream &is, dataio &data);
      friend ostream &operator<<(ostream &os,dataio &data);

      istream &read(istream &is);
      ostream &write(ostream &os);
   
      virtual void startinblock(unsigned i){
      }

      virtual void validate(unsigned n){
      }
   
      virtual bool startoutblock(unsigned i){
         return (i == 0);}
   
      dataio()
      {  resetflags();
         valuesetted=false; 
      }
      void clearinputbuffer();

      void resetflags(bool maprecomendedflagsintomember=true);
      void clear();
      void reset()
      {
         clear();
         resetflags();
         valuesetted = false;
      } // reset()
      virtual ~dataio()
      { unsigned i;
         for(i=0; i< unnamed.size(); i++)  delete unnamed[i];
         for(i=0; i< named.size(); i++)    delete named[i];
      } // ~dataio

      template <class T>
      friend _dataiorec<T>;
   };   // class dataio

// for doxygen usage only (skip or not this part of code)
#ifndef DOXYGEN_SHOULD_SKIP_THIS


// misc  _dataiorec methods that overrrided
   // template<class T>
   // bool _dataiorec<T>::isdataio()
   // {return false;} // to check is the data is dataio. used only when section is active.


   // template <class T>
   // void _dataiorec<T>::startinblock(unsigned i){
   // };

//   template <class T>
//   void _dataiorec<T>::validate(){
//   };

   // template <class T>
   // bool _dataiorec<T>::startoutblock(unsigned i){
   //   return (i ==0);}

   template <class T>
   // T _dataiorec<T>::stringtoitem(string const &s)
   bool _dataiorec<T>::stringtoitem(string &s, T &item)
   {  
      cerr << "_dataiorec<T>::stringtoitem() not implemented" << endl;
      return false;
   }

   template <class T>
   void _dataiorec<T>::itemtostring(T const &item, string &s)
   {
      cerr << "_dataiorec<T>::itemtostring not implemented" << endl;
      s = "_dataiorec<T>::itemtostring not implemented";   
   }

   // binary input/output
   template <class T>
   bool _dataiorec<T>::readitem(istream &is, T &item)
   {  
      cerr << "_dataiorec<T>::readitem() not implemented" << endl;
      return false;
   }

   template <class T>
   void _dataiorec<T>::writeitem(ostream &os, T const &item)
   {
      cerr << "_dataiorec<T>::itemtostring not implemented" << endl;
      os << "_dataiorec<T>::itemtostring not implemented";   
   }

// _dataiorec main methods implementation
// generic implementation, using itemtostring and stringtoitem method


// data dependency _dataiorec methods implementations

// data conversion methods
// string type
// the string coincides with original method ???
// string _dataiorec <string>::stringtoitem(string const &s);
   bool _dataiorec<string>::stringtoitem(string &s, string &item);
   void _dataiorec<string>::itemtostring(string const &item, string &s);

   bool _dataiorec<string>::readitem(istream &is, string &item);
   void _dataiorec<string>::writeitem(ostream &os, string const &item);

// char and wchar_t
   // char _dataiorec <char>::stringtoitem(string const &s);
   bool _dataiorec<char>::stringtoitem(string &s, char &item);
   void _dataiorec<char>::itemtostring(char const &item, string &s);

   bool _dataiorec<char>::readitem(istream &is, char &item);
   void _dataiorec<char>::writeitem(ostream &os, char const &item);

// unsigned char
   // unsigned char _dataiorec <unsigned char>::stringtoitem(string const &s);
   bool _dataiorec<unsigned char>::stringtoitem(string &s, unsigned char &item);
   void _dataiorec<unsigned char>::itemtostring(unsigned char const &item, string  &s);

   bool _dataiorec<unsigned char>::readitem(istream &is, unsigned char &item);
   void _dataiorec<unsigned char>::writeitem(ostream &os, unsigned char const &item);

// wchar_t
   // wchar_t _dataiorec <wchar_t>::stringtoitem(string const &s);
   bool _dataiorec<wchar_t>::stringtoitem(string &s, wchar_t  &item);
   void _dataiorec<wchar_t>::itemtostring(wchar_t const &item, string &s);

   bool _dataiorec<wchar_t>::readitem(istream &is, wchar_t &item);
   void _dataiorec<wchar_t>::writeitem(ostream &os, wchar_t const &item);

// int, unsigned, long, unsigned long
// int
// int _dataiorec <int>::stringtoitem(string const &s);
   bool _dataiorec<int>::stringtoitem(string &s, int &item);
   void _dataiorec<int>::itemtostring(int const &item, string &s);

   bool _dataiorec<int>::readitem(istream &is, int &item);
   void _dataiorec<int>::writeitem(ostream &os, int const &item);
// unsigned
   // unsigned _dataiorec <unsigned>::stringtoitem(string const &s);
   bool _dataiorec<unsigned>::stringtoitem(string &s, unsigned &item);
   void _dataiorec<unsigned>::itemtostring(unsigned const &item, string &s);

   bool _dataiorec<unsigned>::readitem(istream &is, unsigned &item);
   void _dataiorec<unsigned>::writeitem(ostream &os, unsigned const &item);
// long
   // long _dataiorec <long>::stringtoitem(string const &s);
   bool _dataiorec<long>::stringtoitem(string &s, long &item);
   void _dataiorec<long>::itemtostring(long const &item, string &s);

   bool _dataiorec<long>::readitem(istream &is, long &item);
   void _dataiorec<long>::writeitem(ostream &os, long const &item);
// unsigned long
   // unsigned long _dataiorec <unsigned long>::stringtoitem(string const &s);
   bool _dataiorec<unsigned long>::stringtoitem(string &s, unsigned long &item);
   void _dataiorec<unsigned long>::itemtostring(unsigned long const &item, string  &s);

   bool _dataiorec<unsigned long>::readitem(istream &is, unsigned long &item);
   void _dataiorec<unsigned long>::writeitem(ostream &os, unsigned long const &item);

// long long: only for compatibility: it acts as long
   // long _dataiorec <long>::stringtoitem(string const &s);
   bool _dataiorec<long long>::stringtoitem(string &s, long long &item);
   void _dataiorec<long long>::itemtostring(long long const &item, string &s);

   bool _dataiorec<long long>::readitem(istream &is, long long &item);
   void _dataiorec<long long>::writeitem(ostream &os, long long const &item);
// unsigned long long: only for compatibility: acts as long
   // unsigned long _dataiorec <unsigned long>::stringtoitem(string const &s);
   bool _dataiorec<unsigned long long>::stringtoitem(string &s, unsigned long long &item);
   void _dataiorec<unsigned long long>::itemtostring(unsigned long long const &item, string  &s);

   bool _dataiorec<unsigned long long>::readitem(istream &is, unsigned long long &item);
   void _dataiorec<unsigned long long>::writeitem(ostream &os, unsigned long long const &item);

// float, double, and long double
// float
   // float _dataiorec <float>::stringtoitem(string const &s);
   bool _dataiorec<float>::stringtoitem(string &s, float &item);
   // in the input comma separated float, change the string
   void _dataiorec<float>::itemtostring(float const &item, string &s);

   bool _dataiorec<float>::readitem(istream &is, float &item);
   void _dataiorec<float>::writeitem(ostream &os, float const &item);
// double
   // double _dataiorec <double>::stringtoitem(string const &s);
   bool _dataiorec<double>::stringtoitem(string &s, double &item);
   void _dataiorec<double>::itemtostring(double const &item, string &s);

   bool _dataiorec<double>::readitem(istream &is, double &item);
   void _dataiorec<double>::writeitem(ostream &os, double const &item);
// long double
// can not obtain long double. 
// This routine get as double
// it's only for compatibility
   // long double _dataiorec <long double>::stringtoitem(string const &s);
   bool  _dataiorec<long double>::stringtoitem(string &s, long double &item);
   void _dataiorec<long double>::itemtostring(long double const &item, string  &s);

   bool _dataiorec<long double>::readitem(istream &is, long double &item);
   void _dataiorec<long double>::writeitem(ostream &os, long double const &item);

// bool

// bool
   // bool _dataiorec <bool>::stringtoitem(string const &s);
   bool _dataiorec<bool>::stringtoitem(string &s, bool &item);
   void _dataiorec<bool>::itemtostring(bool const &item, string &s);

   bool _dataiorec<bool>::readitem(istream &is, bool &item);
   void _dataiorec<bool>::writeitem(ostream &os, bool const &item);

// for doxygen usage only (skip or not the part of code)
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS

// endding group (for doxygen)
#endif // #define _DATAIO_H_

---