csv_reader.h

#pragma once 
 
#include <string>
#include <vector>
#include <functional>
#include <cgv/utils/convert_string.h>
#include <cgv/utils/advanced_scan.h>
#include <cgv/math/fvec.h>
 
#include <cgv/utils/lib_begin.h>
 
namespace cgv {
    namespace utils {
 
enum CSV_Flags
{
    CSV_HEADING = 1, // whether file starts with heading line
    CSV_COMMA   = 2, // whether comma is a separator
    CSV_TAB     = 4, // whether tab is a separator
    CSV_SPACE   = 8, // whether space is a separating white space (always merged)
    CSV_QUOTES  = 16, // whether quotes are used to combine text to single fields
    CSV_DEFAULT  = CSV_HEADING | CSV_COMMA| CSV_TAB | CSV_QUOTES
};
 
class CGV_API csv_reader_base
{
protected:
    mutable std::string last_error;
    mutable bool failed = false;
    mutable size_t li = 0;
    mutable size_t nr_cols = 0;
 
    CSV_Flags flags;
    std::string content;
    std::vector<std::string> col_names;
    std::vector<cgv::utils::line> lines;
    const char* get_ws() const;
    const char* get_sep() const;
    bool has_heading() const;
    bool find_column_index(const std::string& col_name, size_t& col_index) const;
    csv_reader_base(const std::string& file_name, CSV_Flags _flags = CSV_DEFAULT);
    bool parse_next_line(std::vector<cgv::utils::token>& tokens) const;
public:
    bool fail() const;
};
 
class csv_matrix_reader : public csv_reader_base
{
public:
    csv_matrix_reader(const std::string& file_name, CSV_Flags _flags = CSV_SPACE) : csv_reader_base(file_name, _flags) {}
    template <typename T>
    bool parse_matrix(std::vector<std::vector<T>>& matrix, T init = T(0)) {
        std::vector<cgv::utils::token> tokens;
        while (parse_next_line(tokens)) {
            std::vector<T> vec(tokens.size(), init);
            for (size_t i = 0; i < tokens.size(); ++i)
                cgv::utils::from_string(vec[i], cgv::utils::to_string(tokens[i]));
            matrix.emplace_back(vec);
        }
        return true;
    }
    template <typename T, unsigned N>
    bool parse_matrix(std::vector<cgv::math::fvec<T,N>>& matrix, T init = T(0)) {
        std::vector<cgv::utils::token> tokens;
        while (parse_next_line(tokens)) {
            cgv::math::fvec<T,N> vec(init);
            for (size_t i = 0; i < tokens.size() && i < N; ++i)
                cgv::utils::from_string(vec[int(i)], cgv::utils::to_string(tokens[i]));
            matrix.emplace_back(vec);
        }
        return true;
    }
};
 
 
 
template <typename T>
class csv_reader : public csv_reader_base
{
protected:
    typedef std::pair<size_t, std::function<bool (const std::string&, T&)>> setter;
    std::vector<setter> setters;
public:
    csv_reader(const std::string& file_name, CSV_Flags _flags = CSV_DEFAULT) : csv_reader_base(file_name, _flags) {}
    bool add_entry(size_t col_index, std::function<bool(const std::string&, T&)> s) {
        setters.push_back({ col_index, s });
        return true;
    }
    template <typename M>
    bool add_entry(M T::*ptr, size_t col_index) {
        add_entry(col_index, [ptr](const std::string& tok, T& obj) -> bool {
            return cgv::utils::from_string(obj.*ptr, tok);
        });
        return true;
    }
    template <typename M>
    bool add_entry(M T::* ptr, const std::string& col_name) {
        size_t col_index;
        if (!find_column_index(col_name, col_index))
            return false;
        return add_entry(ptr, col_index);
    }
    bool add_entry(const std::string& col_name, std::function<bool(const std::string&, T&)> s) {
        size_t col_index;
        if (!find_column_index(col_name, col_index))
            return false;
        return add_entry(col_index, s);
    }
    bool parse(std::vector<T>& data)
    {
        std::vector<cgv::utils::token> tokens;
        while (parse_next_line(tokens)) {
            T object;
            for (auto s : setters) {
                if (s.first >= tokens.size()) {
                    last_error = "column index <" + cgv::utils::to_string(s.first) + 
                        "> out of range [0," +cgv::utils::to_string(tokens.size()) + "[";
                    return false;
                }
                if (!s.second(cgv::utils::to_string(tokens[s.first]), object)) {
                    last_error = "could not parse <" + cgv::utils::to_string(tokens[s.first]) + ">";
                    return false;
                }
            }
            data.emplace_back(object);
        }
        return true;
    }
};
 
    }
}
 
#include <cgv/config/lib_end.h>