CSVReader.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
#include <string>
#include <vector>
#include <numeric>
#include <iostream>
#include <sstream>
#include "IString.h"
#include "CSVReader.h"
#include "CollectorMap.h"
#include "IException.h"
 
using namespace std;
 
namespace Isis {
 
  CSVReader::CSVReader() : _header(false), _skip(0),
    _delimiter(','), _keepParts(true), _lines(),
    _ignoreComments(true) { }
 
  CSVReader::CSVReader(const QString &csvfile, bool header, int skip,
                       const char &delimiter, const bool keepEmptyParts,
                       const bool ignoreComments) :
    _header(header), _skip(skip), _delimiter(delimiter),
    _keepParts(keepEmptyParts), _lines(),
    _ignoreComments(ignoreComments) {
 
    read(csvfile);
  }
 
 
  int CSVReader::columns()  const {
    return ((rows() > 0) ? columns(getTable()) : 0);
  }
 
  int CSVReader::columns(const CSVReader::CSVTable &table) const {
    CSVColumnSummary summary = getColumnSummary(table);
    return ((summary.size() > 0) ? summary.key(0) : 0);
  }
 
 
  void CSVReader::read(const QString &csvfile) {
    ifstream ifile(csvfile.toLatin1().data(), ios::in);
    if(!ifile) {
      QString mess = "Unable to open file [" + csvfile + "]";
      throw IException(IException::User, mess, _FILEINFO_);
    }
 
    _lines.clear();
    load(ifile);
    ifile.close();
  }
 
  CSVReader::CSVAxis CSVReader::getHeader() const {
    //  Return an empty header if we don't have one
    if((!_header) || (_skip >= rows())) {
      return (CSVAxis(0));
    }
    return (Parser(_lines[_skip], _delimiter, _keepParts).result());
  }
 
  CSVReader::CSVAxis CSVReader::getRow(int index) const {
    //  Return an empty header if we don't have one
    if((index < 0) || (index >= rows())) {
      return (CSVAxis(0));
    }
    return (Parser(_lines[index+firstRowIndex()], _delimiter, _keepParts).result());
  }
 
 
  CSVReader::CSVAxis CSVReader::getColumn(int index) const {
    //  Return an empty header if we don't have one
    if(index < 0) {
      return (CSVAxis(0));
    }
 
    int nrows(rows());
    int nbad(0);
    CSVAxis column(nrows);
    Parser parser;
    for(int i = 0 ; i < nrows ; i++) {
      parser.parse(_lines[i+firstRowIndex()], _delimiter, _keepParts);
      if(parser.size() <= index) {
//      column[i] = Parser::TokenType("");
        nbad++;
      }
      else {
        column[i] = parser(index);
      }
    }
 
    //  If we had no good columns (index is invalid) return an empty column
    return ((nbad == nrows) ? CSVAxis(0) : column);
  }
 
  CSVReader::CSVAxis CSVReader::getColumn(const QString &hname) const {
    //  Get the header
    CSVAxis header(getHeader());
    QString head = hname.trimmed();
    for(int i = 0 ; i < header.dim() ; i++) {
      if(head.toLower() == header[i].trimmed().toLower()) {
        return (getColumn(i));
      }
    }
 
    //  If we reach here, we did not find the column name
    return (CSVAxis(0));
  }
 
 
  CSVReader::CSVTable CSVReader::getTable() const {
    CSVTable table(rows());
    int nrows(rows());
    Parser parser;
    for(int row = 0 ; row < nrows ; row++) {
      parser.parse(_lines[row+firstRowIndex()], _delimiter, _keepParts);
      table[row] = parser.result();
    }
    return (table);
  }
 
  CSVReader::CSVColumnSummary CSVReader::getColumnSummary(const CSVTable &table)
  const {
    CSVColumnSummary summary;
    for(int row = 0 ; row < table.dim() ; row++) {
      int n(table[row].dim());
      if(summary.exists(n)) {
        int &count = summary.get(n);
        count++;
      }
      else {
        summary.add(n, 1);
      }
    }
 
    return (summary);
  }
 
  bool CSVReader::isTableValid(const CSVReader::CSVTable &table) const {
    CSVColumnSummary summary = getColumnSummary(table);
    return (summary.size() <= 1);
  }
 
  std::istream &CSVReader::load(std::istream &ifile) {
 
    std::string iline;
    int nlines(0);
    while(getline(ifile, iline)) {
      if(!iline.empty()) {
        if(!(_ignoreComments && (iline[0] == '#'))) {
          _lines.push_back(iline.c_str());
          nlines++;
        }
      }
    }
 
    if(!ifile.eof()) {
      ostringstream mess;
      mess << "Error reading line [" << (nlines + 1) << "]" << ends;
      throw IException(IException::User, mess.str(), _FILEINFO_);
    }
 
    return (ifile);
  }
 
  std::istream &operator>>(std::istream &is, CSVReader &csv) {
    return (csv.load(is));
  }
 
}