CsvInterface.h

Go to the documentation of this file.

 
#pragma once
 
#include <any>
#include <array>
#include <fstream>
#include <iterator>
#include <limits>
#include <list>
#include <string>
#include <typeinfo>
#include <vector>
 
#include "BaseLib/IO/Writer.h"
#include "BaseLib/Logging.h"
#include "BaseLib/StringTools.h"
 
namespace GeoLib
{
class Point;
}
 
namespace FileIO
{
class CsvInterface : public BaseLib::IO::Writer
{
public:
    CsvInterface();
 
    std::size_t getNArrays() const { return _vec_names.size(); }
 
    static std::vector<std::string> getColumnNames(std::string const& fname,
                                                   char delim);
 
    void addIndexVectorForWriting(std::size_t s);
 
    void setCsvHeader(bool write_header) { _writeCsvHeader = write_header; }
 
    template <typename T>
    bool addVectorForWriting(std::string const& vec_name,
                             std::vector<T> const& vec)
    {
        static_assert(
            std::is_same_v<T, std::string> || std::is_same_v<T, double> ||
                std::is_same_v<T, int>,
            "CsvInterface can only write vectors of strings, doubles or ints.");
 
        if (!_data.empty())
        {
            std::size_t const vec_size(getVectorSize(0));
            if (vec_size != vec.size())
            {
                ERR("Vector size does not match existing data (should be "
                    "{:d}).",
                    vec_size);
                return false;
            }
        }
 
        _vec_names.push_back(vec_name);
        _data.push_back(vec);
        return true;
    }
 
    bool write() override;
 
    static int readPoints(std::string const& fname, char delim,
                          std::vector<GeoLib::Point*>& points);
 
    static int readPoints(std::string const& fname, char delim,
                          std::vector<GeoLib::Point*>& points,
                          std::string const& x_column_name,
                          std::string const& y_column_name,
                          std::string const& z_column_name = "");
 
    static int readPoints(
        std::string const& fname, char delim,
        std::vector<GeoLib::Point*>& points, std::size_t x_column_idx,
        std::size_t y_column_idx,
        std::size_t z_column_idx = std::numeric_limits<std::size_t>::max());
 
    template <typename T>
    static std::pair<int, std::vector<T>> readColumn(
        std::string const& fname, char delim, std::string const& column_name)
    {
        std::ifstream in(fname.c_str());
        if (!in.is_open())
        {
            ERR("CsvInterface::readColumn(): Could not open file {:s}.", fname);
            return {-1, {}};
        }
 
        std::string line;
        std::getline(in, line);
        std::size_t const column_idx =
            CsvInterface::findColumn(line, delim, column_name);
        if (column_idx == std::numeric_limits<std::size_t>::max())
        {
            ERR("Column '{:s}' not found in file header.", column_name);
            return {-1, {}};
        }
        return readColumn<T>(in, delim, column_idx);
    }
 
    template <typename T>
    static std::pair<int, std::vector<T>> readColumn(std::string const& fname,
                                                     char delim,
                                                     std::size_t column_idx)
    {
        std::ifstream in(fname.c_str());
        if (!in.is_open())
        {
            ERR("CsvInterface::readColumn(): Could not open file {:s}.", fname);
            return {-1, {}};
        }
        return readColumn<T>(in, delim, column_idx);
    }
 
private:
    static int readPoints(std::ifstream& in, char delim,
                          std::vector<GeoLib::Point*>& points,
                          std::array<std::size_t, 3> const& column_idx);
 
    template <typename T>
    static std::pair<int, std::vector<T>> readColumn(std::ifstream& in,
                                                     char delim,
                                                     std::size_t column_idx)
    {
        std::vector<T> data_array;
        std::string line;
        std::size_t line_count(0);
        int error_count(0);
        while (std::getline(in, line))
        {
            line_count++;
            std::list<std::string> const fields =
                BaseLib::splitString(line, delim);
 
            if (fields.size() < column_idx + 1)
            {
                ERR("Line {:d} contains not enough columns of data. Skipping "
                    "line...",
                    line_count);
                error_count++;
                continue;
            }
            auto it = fields.begin();
            std::advance(it, column_idx);
 
            std::istringstream stream(*it);
            T value;
            if (!(stream >> value))
            {
                ERR("Error reading value in line {:d}.", line_count);
                error_count++;
                continue;
            }
 
            data_array.push_back(value);
        }
        return {error_count, data_array};
    }
 
    static std::size_t findColumn(std::string const& line, char delim,
                                  std::string const& column_name);
 
    std::size_t getVectorSize(std::size_t idx) const;
 
    void writeValue(std::size_t vec_idx, std::size_t in_vec_idx);
 
    bool _writeCsvHeader{true};
    std::vector<std::string> _vec_names;
    std::vector<std::any> _data;
};
 
}  // namespace FileIO