DataFileReader.hpp

// Unfit: Data fitting and optimization software
//
// Copyright (C) 2012- Dr Martin Buist & Dr Alberto Corrias
// Contacts: martin.buist _at_ nus.edu.sg; alberto _at_ nus.edu.sg
//
// See the 'Contributors' file for a list of those who have contributed
// to this work.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
#ifndef UNFIT_INCLUDE_DATAFILEREADER_HPP_
#define UNFIT_INCLUDE_DATAFILEREADER_HPP_

#include <fstream>
#include <limits>
#include <sstream>
#include <string>
#include <vector>

namespace Unfit
{
template <typename T>
  struct DataFileReader
{
  DataFileReader();

  unsigned ReadFile(std::string file_name, unsigned skip = 0);

  void AddDelimiters(const std::string &new_delimiters);

  unsigned RetrieveColumn(std::size_t column_number, std::vector<T> &column,
      bool return_incomplete_columns = false);

  std::vector<T> RetrieveDataRowWiseAsVector();

  void SplitLine(const std::string &line, const std::string &delimiters,
      std::vector<std::string> &words);

  std::vector<std::vector<T>> data;
  std::string default_delimiters;
};


template <class T>
  DataFileReader<T>::DataFileReader() :
    data(),
    default_delimiters("\t ,")
{}


template <class T>
  unsigned DataFileReader<T>::ReadFile(std::string file_name, unsigned skip)
{
  // Just in case this is not the first time, make sure we start from scratch
  data.clear();
  // Attempt to open the file, then check it is open
  std::ifstream data_file(file_name.c_str());
  if (!data_file.is_open()) return 1;
  // Read in the data, one line at a time
  while (data_file.good()) {
    // Get a line
    std::string line;
    getline(data_file, line);
    // Split the line based on the delimiters
    std::vector<std::string> words;
    SplitLine(line, default_delimiters, words);
    // Skip the first "skip" numeric lines if requested
    if (skip > 0) {
      --skip;
      continue;
    }
    // Convert to type T then store in a vector
    std::vector<T> numbers;
    for (auto entry = 0u; entry < words.size(); ++entry) {
      std::stringstream ss;
      ss << words[entry].c_str();
      long double value;
      // Check we have a number before including it
      if (ss >> value) {
        // Check the maximum size is okay
        if (value > std::numeric_limits<T>::max()) {
          data.clear();
          return 2;
        }
        // Check the maximum negative size is okay
        // Use std::numeric_limits::lowest when available
        if (std::numeric_limits<T>::is_integer) {
          if (value < std::numeric_limits<T>::min()) {
            data.clear();
            return 3;
          }
        }
        else if (value <
            -static_cast<long double>(std::numeric_limits<T>::max())) {
          data.clear();
          return 3;
        }
        numbers.push_back(static_cast<T>(value));
      }
    }
    // If the line contained numbers, put these into a row of the data vector
    if (!numbers.empty()) data.push_back( numbers );
  }
  if (data.empty()) return 4;
  return 0;
}


template <class T>
  void DataFileReader<T>::AddDelimiters(const std::string &new_delimiters)
{
  default_delimiters += new_delimiters;
}


template <class T>
  unsigned DataFileReader<T>::RetrieveColumn(std::size_t column_number,
    std::vector<T> &column, bool return_incomplete_columns)
{
  column.clear();
  if (data.empty()) return 1;
  std::size_t min_row_length = std::numeric_limits<std::size_t>::max();
  std::size_t max_row_length = 0u;
  for (auto d : data) {
    if (d.size() < min_row_length) min_row_length = d.size();
    if (d.size() > max_row_length) max_row_length = d.size();
  }
  if (column_number >= max_row_length) return 2;  // Column does not exist
  if (column_number >= min_row_length) {  // Column is incomplete
    if (return_incomplete_columns) {
      for (auto i = 0u; i < data.size(); ++i) {
        if (data[i].size() > column_number) {
          column.push_back(data[i][column_number]);
        }
      }
    }
    return 3;
  }
  else {
    column.resize(data.size());
    for (auto i = 0u; i < data.size(); ++i) {
      column[i] = data[i][column_number];
    }
    return 0;
  }
}


template <class T>
  std::vector<T> DataFileReader<T>::RetrieveDataRowWiseAsVector()
{
  // This does a range insert for every row of data in order
  std::vector<T> result;
  for (auto d : data) {
    result.insert(end(result), begin(d), end(d));
  }
  return result;
}


template <class T>
  void DataFileReader<T>::SplitLine(const std::string &line,
    const std::string &delimiters, std::vector<std::string> &words)
{
  // Get the first word from the line
  auto word_start = line.find_first_not_of(delimiters, 0);
  auto word_end = line.find_first_of(delimiters, word_start);

  // While we have not hit the end of the string
  while (word_start != std::string::npos || word_end != std::string::npos) {
    // Add the current word to the list (vector)
    words.push_back(line.substr(word_start, (word_end-word_start)));
    // Get the next word in the line
    word_start = line.find_first_not_of(delimiters, word_end);
    word_end = line.find_first_of(delimiters, word_start);
  }
}

}  // namespace Unfit

#endif