csvFile.hpp

#ifndef CSV_FILE_HPP
#define CSV_FILE_HPP

#include <typeinfo>
#include <string>
#include <sstream>
#include <map>
#include <fstream>
#include "boost/numeric/ublas/matrix.hpp"
#include "kernel/kernelException.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/tokenizer.hpp"

namespace jafar {
  namespace kernel {

    class CSVFile {

      private:

      std::string m_separator;
      char m_commentPrefix;
      bool withColumnsNames;
      std::map<std::string, int> columnNames;
      typedef boost::numeric::ublas::matrix<std::string> stringMatrix;
      stringMatrix fileMatrix;
      size_t lineNumber;
      size_t dataLineNumber;
      size_t columnNumber;
      static void compute_matrix_size(const std::string& _file, 
                                      size_t& nb_lines,
                                      size_t& nb_columns,
                                      const std::string& _separator = " ",
                                      char _commentPrefix = '#');
      public:

      CSVFile(std::string const& separator_ = " ", char commentPrefix_ = '#', bool withColumnsNames_ = false);

      void readFile(std::string const& filename);

      void writeFile(std::string const& filename);
      void hasColumnsNames(const bool& _withColumnsNames);
      bool hasColumn(std::string const& columnName) const;
      size_t nbOfLines() const;
      size_t nbOfColumns() const;
      inline std::string separator() const {
        return m_separator;
      }
      inline char commentPrefix() const {
        return m_commentPrefix;
      }
      template<class T>
        void getItem(size_t line, size_t columnNumber, T& value) const {

        JFR_PRED_ERROR(line >= 0 && line < fileMatrix.size1(),
                       KernelException,
                       KernelException::CSVFILE_UNKNOWN_LINE,
                       "CSVFile:getItem: unknown line: " << line);
        
        JFR_PRED_ERROR(columnNumber >= 0 && columnNumber < fileMatrix.size2(),
                       KernelException,
                       KernelException::CSVFILE_UNKNOWN_COLUMN,
                       "CSVFile:getItem: unknown column: " << columnNumber);
        std::istringstream ss(fileMatrix(line, columnNumber));
        ss >> value;

        JFR_IO_STREAM(ss, 
                      "CSVFile::getItem: invalid value parsing:" << std::endl << 
                      "line: " << line << std::endl <<
                      "column: " << columnNumber << std::endl <<
                      "value: " << fileMatrix(line, columnNumber) << std::endl <<
                      "value-type: " << typeid(T).name());
      } 

      template<class T>
        void getItem(size_t line, const std::string& columnName, T& value) const {
        std::map<std::string,int>::const_iterator iter = columnNames.find(columnName);
        JFR_PRED_ERROR(iter != columnNames.end(),
           KernelException,
           KernelException::CSVFILE_UNKNOWN_COLUMN_NAME,
           "CSVFile:getItem: unknown column name: " << columnName);

        int colNbr = iter->second;
        getItem<T>(line, colNbr, value);
      }

      template<class T>
        void setItem(size_t line, size_t column, const T& value) {
        if (fileMatrix.size1() < line+1) {
          fileMatrix.resize((line+1), fileMatrix.size2(), true);
        }
        if (fileMatrix.size2() < column+1) {
          fileMatrix.resize(fileMatrix.size1(), (column+1), true);
        }
  std::ostringstream ss;
  ss << value;
        fileMatrix(line, column) = ss.str();
      }

      template<class T>
        void setItem(size_t line, const std::string& colName, const T& value) {
        std::map<std::string,int>::const_iterator iter = columnNames.find(colName);
        JFR_PRED_ERROR(iter != columnNames.end(),
           KernelException,
           KernelException::CSVFILE_UNKNOWN_COLUMN_NAME,
           "CSVFile:getItem: unknown column name: " << colName);

        int colNbr = iter->second;
        setItem<T>(line, colNbr, value);
      }

    }; // class CSVFile

    class CSVFileLoad {

      public:

      void load(std::string const& filename,
    std::string const& separator_ = " ", char commentPrefix_ = '#');

      protected:

      virtual ~CSVFileLoad() {}

      virtual void loadCSVFile(jafar::kernel::CSVFile& csvFile) = 0;
      
    }; // class CSVFileLoad


    class CSVFileSave {

      public:

      void save(std::string const& filename,
    std::string const& separator_ = " ", char commentPrefix_ = '#');

      protected:

      virtual ~CSVFileSave() {}

      virtual void saveCSVFile(jafar::kernel::CSVFile& csvFile) = 0;

    }; // class CSVFileSave

    class CSVFileSaveLoad : public CSVFileLoad, public CSVFileSave {

    }; // class CSVFileSaveLoad

  } // namespace kernel
} // namespace jafar

#endif // KERNEL_KEY_VALUE_FILE_HPP