CSVReader.h

#ifndef CSVReader_h
#define CSVReader_h
/* SPDX-License-Identifier: CC0-1.0 */
 
#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? Qt::KeepEmptyParts : Qt::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