data.h

Go to the documentation of this file.

#ifndef DATA_H
#define DATA_H

#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <cstdlib>

namespace mimas {
  
template <typename T> class data;

template <typename T>
ostream &operator<<(ostream &output, const data<T> &outdata);


template <typename T>
class data
{
   friend ostream &operator<<(ostream &output, const data<T> &outdata);

    private:
  bool getHeader(ifstream &infile);
  string toLower(string &instring);
  int getIntAfterString(ifstream &infile, const char *cheader);
  void stripComment(string &instring);
  void trimDelimeters(string &instring);
  void trimWhiteSpaces(string &instring);
  
  float refNumber;

    protected:
  int numInputTuples, numOutputTuples;
  int numLines;
  vector < vector <T> > inputTuple;
  vector < vector <T> > outputTuple;

    public:
  int readFromFile(const char *fn); 
  int writeToFile(const char *fn); 
  T getInputValue(int line, int tuple); 
  void setInputValue(int line, int tuple, T val); 
  T getOutputValue(int line, int tuple); 
  void setOutputValue(int line, int tuple, T val); 
  void init(int lines, int inputtuples, int outputtuples); 
  void clear(void); 
  
  data(void); 
  ~data(void); 
  


}; 


template <typename T>
data<T>::data(void)
{
    numInputTuples=-1;
    numOutputTuples=-1;
    numLines=-1;
}
    
template <typename T>
data<T>::~data(void)
{
}

template <typename T>
void data<T>::init(int lines, int inputtuples, int outputtuples)
{
    clear();
    vector <T> v;

    for (int i=0; i<inputtuples; i++)
  v.push_back((T)0);

    for (int i=0; i<lines; i++)
  inputTuple.push_back(v);

    v.clear();

    for (int i=0; i<outputtuples; i++)
  v.push_back((T)0);

    for (int i=0; i<lines; i++)
  outputTuple.push_back(v);

    numLines=lines;
    numInputTuples=inputtuples;
    numOutputTuples=outputtuples;
}


template <typename T>
void data<T>::clear(void)
{
    for (int i=0; i<numInputTuples; i++)
  inputTuple[i].clear();
    inputTuple.clear();
    
    for (int i=0; i<numOutputTuples; i++)
  outputTuple[i].clear();
    outputTuple.clear();

    numLines=0;
    numInputTuples=0;
    numOutputTuples=0;
} 


template <typename T>
T data<T>::getInputValue(int line, int tuple)
{
    T retval;
    
    if ((line>=0) && (line<numLines) && (tuple>=0) && (tuple<numInputTuples))
      retval=inputTuple[line][tuple];
    else
    {
  cerr << "ERROR: data::getInputValue out of range" << std::endl;
  exit(1);
    }

    return retval;
}
 
template <typename T>
T data<T>::getOutputValue(int line, int tuple)
{  
    T retval;
    
    if ((line>=0) && (line<numLines) && (tuple>=0) && (tuple<numOutputTuples))
      retval=outputTuple[line][tuple];
    else
    {
  cerr << "ERROR: data::getOutputValue out of range" << std::endl;
  exit(1);
    }

    return retval;
}
    


template <typename T>
void data<T>::setInputValue(int line, int tuple, T val) 
{  
    
    if ((line>=0) && (line<numLines) && (tuple>=0) && (tuple<numInputTuples))
      inputTuple[line][tuple]=val;
    else
    {
  cerr << "ERROR: data::setInputValue out of range" << std::endl;
  exit(1);
    }

}


    
template <typename T>
void data<T>::setOutputValue(int line, int tuple, T val) 
{  
    
    if ((line>=0) && (line<numLines) && (tuple>=0) && (tuple<numOutputTuples))
      outputTuple[line][tuple]=val;
    else
    {
  cerr << "ERROR: data::setInputValue out of range" << std::endl;
  exit(1);
    }

}




template <typename T>
string data<T>::toLower(string &instring)
{
    string lower;

    for (int k=0; k<instring.length(); k++)
  lower+=tolower(instring[k]);
    
    return lower;
}

template <typename T>
bool data<T>::getHeader(ifstream &infile)
{
    string line, lcaseline;
    string header="# mimas datafile format";
    
    while (getline(infile, line))
    {
  if (toLower(line).find(header,0)==-1) continue;
  cout << line << std::endl;
  refNumber=atof(line.substr(header.length(),line.length()-header.length()).c_str());
  cout << refNumber << std::endl;
  break;
    }

    return true;
 }

    
template <typename T>
int data<T>::getIntAfterString(ifstream &infile, const char *cheader)
{
    string line, lcaseline;
    string header(cheader);
    int retint;
   
    retint=-1; 
    while (getline(infile, line))
    {
  if (toLower(line).find(header,0)==-1) continue;
  cout << line << std::endl;
  retint=atoi(line.substr(header.length(),line.length()-header.length()).c_str());
  break;
    }

    cout << header << std::endl;
    return retint;
 }

template <typename T>
void data<T>::stripComment(string &instring)
{
    string comment="#";

    instring=instring.substr(0,instring.find(comment,0));
}

template <typename T>
void data<T>::trimDelimeters(string &instring)
{
    string unwantedstring;


    // Replace commas with spaces
    unwantedstring=',';
    while (instring.find(unwantedstring,0)!=-1)
    {
  int unwantedcharloc=instring.find(unwantedstring,0);
  instring.replace(unwantedcharloc,1,' ');
    }
    
    // Replace single quotes with spaces
    unwantedstring="\'";
    while (instring.find(unwantedstring,0)!=-1)
    {
  int unwantedcharloc=instring.find(unwantedstring,0);
  instring.replace(unwantedcharloc,1,' ');
    }
    
    // Replace double quotes with spaces
    unwantedstring="\"";
    while (instring.find(unwantedstring,0)!=-1)
    {
  int unwantedcharloc=instring.find(unwantedstring,0);
  instring.replace(unwantedcharloc,1,' ');
    }
 }

 
template <typename T>
void data<T>::trimWhiteSpaces(string &instring)
{
    if (instring=="") return;

    string unwantedstring;

    // Replace tabs with spaces
    unwantedstring='\t';
    while (instring.find(unwantedstring,0)!=-1)
    {
  int unwantedcharloc=instring.find(unwantedstring,0);
  instring.replace(unwantedcharloc,1,' ');
    }
    
    // Replace newline with spaces
    unwantedstring='\r';
    while (instring.find(unwantedstring,0)!=-1)
    {
  int unwantedcharloc=instring.find(unwantedstring,0);
  instring.replace(unwantedcharloc,1,' ');
    }
    
    // Replace carriage return with spaces
    unwantedstring='\n';
    while (instring.find(unwantedstring,0)!=-1)
    {
  int unwantedcharloc=instring.find(unwantedstring,0);
  instring.replace(unwantedcharloc,1,' ');
    }
    
    // Truncate double spaces with spaces
    unwantedstring="  ";
    while (instring.find(unwantedstring,0)!=-1)
    {
  int unwantedcharloc=instring.find(unwantedstring,0);
  instring.erase(unwantedcharloc,1);
    }

    
    // Remove leading spaces
    unwantedstring=" ";
    while (instring.find(unwantedstring,0)==0)
    {
  instring.erase(0,1);
    }
    if (instring=="") return;
    
    // Remove trailing spaces
    unwantedstring=' ';
    while (instring.find(unwantedstring,instring.length()-1)==instring.length()-1)
    {
  instring.erase(instring.length()-1,1);
    }
    
}


template <typename T>
ostream &operator<<(ostream &output, const data<T> &outdata)
{
    output << "# Mimas datafile format" << std::endl;
    output << "# input tuples: " << outdata.numInputTuples << std::endl;
    output << "# output tuples: " << outdata.numOutputTuples << std::endl;
    // output << "# Datasize: in  " << outdata.inputTuple.size() << " x " << outdata.inputTuple[0].size() << std::endl;
    // output << "# Datasize: out " << outdata.outputTuple.size() << " x " << outdata.outputTuple[0].size() << std::endl;
    
    for (int l=0; l<outdata.numLines; l++)
    {
  for (int i=0; i<outdata.numInputTuples; i++)
      output << " " << outdata.inputTuple[l][i] ;
  
  output << "   " ;
  
  for (int i=0; i<outdata.numOutputTuples; i++)
      output << "  " << outdata.outputTuple[l][i] ;

  output << std::endl;
    
    }
    return output;
}



template <typename T>
int data<T>::readFromFile(const char *fn)
{
    ifstream infile(fn);
    getHeader(infile);
    
    numInputTuples=getIntAfterString(infile, "# input tuples:");
    numOutputTuples=getIntAfterString(infile, "# output tuples:");

    cout << "Inputs : " << numInputTuples << std::endl;
    cout << "Outputs : " << numOutputTuples << std::endl;


    string line;
    int incount=0, outcount=0;
    numLines=0;
    vector<T> in,out;

    while(getline(infile,line))
    {
  trimDelimeters(line);
  trimWhiteSpaces(line);
  stripComment(line);
  if (line.length()==0) continue;
  

  char *charline=(char *)line.c_str();
  char *pEnd, *pStart, *pPrev;
  double dblval;

  pStart=charline;
  pPrev=pStart;
  while (strlen(pStart)!=0)
  {
      if ((outcount+incount)>=(numOutputTuples+numInputTuples))
      {
    inputTuple.push_back(in);
    outputTuple.push_back(out);
    in.clear();
    out.clear();
    incount=0;
    outcount=0;
    numLines++;
      }
        
      dblval = strtod (pStart,&pEnd);

      if (incount!=numInputTuples)
      {
    in.push_back((T)dblval);
    incount++;
      }
      else
      {
    if (outcount!=numOutputTuples)
    {
        out.push_back((T)dblval);
        outcount++;
    }
      }
      
      cout << "extracted : " << dblval << std::endl;
      pPrev=pStart;
      pStart=pEnd;

      if (pPrev==pStart)
      {
    cerr << "Error" << std::endl;
    exit(1);
      }

  }

    }


    if ((outcount+incount)>=(numOutputTuples+numInputTuples))
    {
  inputTuple.push_back(in);
  outputTuple.push_back(out);
  in.clear();
  out.clear();
  numLines++;
    }
    else
  cout << "# Warning: ignoring some lines due to incomplete data" << std::endl;

    cout << numLines << " " << incount << " " << outcount << std::endl;
      
   return 0;
}

template <typename T>
int data<T>::writeToFile(const char *fn)
{    
    ofstream outfile(fn);
    
    outfile << (*this) ;

    outfile.close();
 
    return 0;
}

/* Test */
/*
int main()
{
    data<float> test;
    test.readFromFile("test.dat");
    cout << test << std::endl;
    test.setInputValue(1,5,9999);
    cout << test << test.getOutputValue(1,0) << std::endl;


    test.clear();
    cout << std::endl << std::endl;
    cout << test << std::endl;

    test.init(3,3,2);    
    cout << test << std::endl;
    
    return 0;
}
*/

}

#endif

---