Csv.h

Go to the documentation of this file.

 
#pragma once
 
#include "../constants.h"
#include <cstdint>
#include <cstring>
#include <fstream>
#include <iostream>
#include <optional>
#include <sstream>
#include <string_view>
#include <tuple>
#include <vector>
 
namespace tsunami_lab {
namespace io {
class Csv;
}
}
 
class tsunami_lab::io::Csv {
  public:
    static void write(
        t_real i_dxy, t_idx i_nx, t_idx i_ny, t_idx i_stride, t_real const *i_h, t_real const *i_hu,
        t_real const *i_hv, t_real const *i_bm, std::ostream &io_stream
    );
 
    // completely in header file for template reasons
    template <typename... Types>
    static std::vector<std::tuple<Types...>>
    getRows(std::string filename, std::uint32_t skipLines, std::uint32_t maxRows = 0) {
        // read file as stream
        std::ifstream in(filename);
        if (!in)
            throw std::runtime_error("Couldn't open file: " + filename);
 
        std::vector<std::tuple<Types...>> rows;
 
        // go through file line by line
        std::string current;
        while (std::getline(in, current)) {
            // skip lines ignore empty and comment lines
            if (current.empty())
                continue;
            if (current[0] == '#')
                continue;
 
            if (skipLines > 0) {
                skipLines--;
                continue;
            }
 
            std::vector<std::string> field_list;
 
            std::istringstream row_stream(current);
            std::string field;
            // brake up line in fields
            while (std::getline(row_stream, field, ',')) {
                // trim fields
                const char *whitespaces = " \t\r\n";
 
                auto start = field.find_first_not_of(whitespaces);
                if (start == std::string::npos) {
                    field_list.push_back("");
                    continue;
                };
                auto end = field.find_last_not_of(whitespaces);
 
                // push trimmed field to field list
                field_list.push_back(field.substr(start, end - start + 1));
            }
 
            // row is done, push to array
            rows.push_back(castLine<Types...>(field_list));
 
            // stop early if a row limit is set
            if (maxRows > 0 && rows.size() >= maxRows)
                break;
        }
 
        return rows;
    }
 
  private:
    // using this as a consversion from string to T, not ideal but works for base types
    template <typename T> static T convert(const std::string str) {
        std::istringstream stream(str);
        T val;
        stream >> val;
        return val;
    }
 
    // using variadic templates with a recursive implementation to have a generic csv reader
 
    // base to catch last type
    template <typename Last> static std::tuple<Last> castLine(std::vector<std::string> string_row) {
        if (string_row.size() < 1)
            throw std::runtime_error("Couldn't parse line, too few cells in row");
 
        return std::make_tuple(convert<Last>(string_row[0]));
    }
 
    // work through each type one by one
    template <typename First, typename... Types>
        requires(sizeof...(Types) != 0)
    static std::tuple<First, Types...> castLine(std::vector<std::string> string_row) {
        if (string_row.size() < 1)
            throw std::runtime_error("Couldn't parse line, too few cells in row");
 
        std::vector<std::string> sub;
        sub.assign(string_row.begin() + 1, string_row.end());
 
        auto rest = castLine<Types...>(sub);
 
        // attach new element to tuple
        return std::tuple_cat(std::make_tuple(convert<First>(string_row[0])), rest);
    }
};