CSVParser.hpp

#pragma once
#include <eris/noncopyable.hpp>
#include <string>
#include <unordered_set>
#include <unordered_map>
#include <vector>
#include <fstream>

namespace creativity { namespace data {

class CSVParser : private eris::noncopyable {
    public:
        CSVParser() = delete;
        explicit CSVParser(const std::string &filename);

        const std::unordered_set<std::string>& skip() const;

        void skip(const std::string &name);

        void dontSkip(const std::string &name);

        const std::vector<std::string>& header() const;

        const std::vector<std::string>& fields() const;

        bool hasField(const std::string &field) const;

        size_t fieldPosition(const std::string &field) const;

        double field(const std::string &field) const;

        size_t allow_missing_values = 0;

        bool readRow();

        bool eof() const;

        const std::vector<double>& row() const { return row_; }

        const std::unordered_map<std::string, std::string>& rowSkipped() const { return row_skipped_; }

        const size_t& lineNumber() const { return lineno_; }

        // forward declaration
        class iterator;

        iterator begin();

        iterator end();

    private:
        // Split a string by , and return a vector of elements
        static std::vector<std::string> split(const std::string &csr);

        void updateFields(); // regenerate fields, omitting things in skip_
        std::unordered_set<std::string> skip_; // things to skip in header_ when making fields_
        std::vector<std::string> header_; // the header read from the file
        std::vector<std::string> fields_; // the header fields remaining after skipping skip_
        mutable std::unordered_map<std::string, unsigned> field_pos_; // Map from field name to row position (created from fields_ on-demand)
        std::fstream f_;
        size_t lineno_; // Tracks the current line number
        std::vector<double> row_; // The most-recently-read row (reused)
        std::unordered_map<std::string, std::string> row_skipped_; // Any skipped fields on most-recently-read row
};

class CSVParser::iterator final : public std::iterator<std::input_iterator_tag, const std::vector<double>, long> {
    public:
        reference operator*() { return csv_.row(); }

        pointer operator->() { return &csv_.row(); }

        iterator& operator++() { end_ = not csv_.readRow(); return *this; }

        bool operator==(const iterator &other) {
            return
                &csv_ == &(other.csv_) // same CSV object
                and
                end_ == other.end_; // Both are end (either by calling end() or by hitting eof)
        }

        bool operator!=(const iterator &other) { return !(*this == other); }

    private:
        iterator() = delete;
        CSVParser &csv_;
        bool end_; // true if this is a past-the-end iterator
        iterator(CSVParser &csv, bool end) : csv_(csv), end_(end) { if (!end_) csv_.readRow(); }
        friend class CSVParser;
};

}}