CSVReader.h

Go to the documentation of this file.

#ifndef CSVReader_h
#define CSVReader_h

#include <QString>
#include <vector>
#include <fstream>
#include <tnt/tnt_array1d.h>
#include "CollectorMap.h"
#include "IException.h"
#include "IString.h"

namespace Isis {

  template <typename TokenStore = QString>
  class CSVParser {
    public:
      typedef TokenStore              TokenType;  
      typedef TNT::Array1D<TokenType> TokenList;  

      CSVParser() { }
      virtual ~CSVParser()  { }

      CSVParser(const QString &str, const char &delimiter = ',',
                bool keepEmptyParts = true) {
        parse(str, delimiter, keepEmptyParts);
      }

      int size() const {
        return (_elements.dim());
      }

      const TokenType &operator()(const int nth) const {
        return (_elements[nth]);
      }

      int parse(const QString &str, const char &delimiter = ',',
                bool keepEmptyParts = true) {
        QStringList tokens =
            str.split(delimiter, keepEmptyParts? QString::KeepEmptyParts : QString::SkipEmptyParts);
        TokenList slist(tokens.size());
        for(int i = 0 ; i < tokens.size() ; i++) {
          slist[i] = TokenType(tokens[i]);
        }
        _elements = slist;
        return (_elements.dim());
      }

      TokenList result() const {
        return (_elements);
      }

    private:
      TokenList _elements;   
  };



  class CSVReader {

    private:
      typedef CSVParser<QString> Parser;    

    public:
      friend std::istream &operator>>(std::istream &is, CSVReader &csv);

      typedef Parser::TokenList       CSVAxis;   
      typedef TNT::Array1D<CSVAxis>   CSVTable;  
      typedef CollectorMap<int, int>   CSVColumnSummary;  

      typedef TNT::Array1D<double>    CSVDblVector;  
      typedef TNT::Array1D<int>       CSVIntVector;  

      // Constructors and Destructor
      CSVReader();
      CSVReader(const QString &csvfile, bool header = false, int skip = 0,
                const char &delimiter = ',', const bool keepEmptyParts = true,
                const bool ignoreComments = true);

      virtual ~CSVReader() { }

      int size() const {
        return (_lines.size());
      }

      int rows() const {
        int nrows(_lines.size() - firstRowIndex());
        return ((nrows < 0) ? 0 : nrows);
      }

      int columns() const;
      int columns(const CSVTable &table) const;

      void setComment(const bool ignore = true) {
        _ignoreComments = ignore;
      }

      void setSkip(int nskip) {
        if(nskip >= 0) _skip = nskip;
      }

      int  getSkip() const {
        return (_skip);
      }

      bool haveHeader() const {
        return (_header);
      }

      void setHeader(const bool gotIt = true) {
        _header = gotIt;
      }


      void setDelimiter(const char &delimiter) {
        _delimiter = delimiter;
      }

      char getDelimiter() const {
        return (_delimiter);
      }

      void setKeepEmptyParts() {
        _keepParts = true;
      }

      void setSkipEmptyParts() {
        _keepParts = false;
      }

      bool keepEmptyParts() const {
        return (_keepParts);
      }

      void read(const QString &fname);

      CSVAxis getHeader() const;
      CSVAxis getRow(int index) const;
      CSVAxis getColumn(int index) const;
      CSVAxis getColumn(const QString &hname) const;
      CSVTable   getTable() const;
      bool isTableValid(const CSVTable &table) const;

      CSVColumnSummary getColumnSummary(const CSVTable &table) const;

      template <typename T> TNT::Array1D<T> convert(const CSVAxis &data) const;

      void clear() {
        _lines.clear();
      }

    private:
      typedef std::vector<QString> CSVList; 
      bool          _header;     
      int           _skip;       
      char          _delimiter;  
      bool          _keepParts;  
      CSVList       _lines;      
      bool          _ignoreComments; 

      int firstRowIndex() const {
        return (_skip + ((_header) ? 1 : 0));
      }

      std::istream &load(std::istream &ifile);
  };


  template <typename T>
  TNT::Array1D<T> CSVReader::convert(const CSVAxis &data) const {
    TNT::Array1D<T> out(data.dim());
    for(int i = 0 ; i < data.dim() ; i++) {
      Parser::TokenType s = data[i];
      out[i] = toDouble(s);
    }
    return (out);
  }
}


#endif