csv_reader.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <deque>
#include <fstream>
#include <iterator>
#include <memory>
#include <mutex>
#include <thread>
#include <sstream>
#include <string>
#include <vector>
 
#include "../external/mio.hpp"
#include "basic_csv_parser.hpp"
#include "common.hpp"
#include "data_type.h"
#include "csv_format.hpp"
 
namespace csv {
    namespace internals {
        std::string format_row(const std::vector<std::string>& row, csv::string_view delim = ", ");
 
        std::vector<std::string> _get_col_names( csv::string_view head, const CSVFormat format = CSVFormat::guess_csv());
 
        struct GuessScore {
            double score;
            size_t header;
        };
 
        CSV_INLINE GuessScore calculate_score(csv::string_view head, CSVFormat format);
 
        CSVGuessResult _guess_format(csv::string_view head, const std::vector<char>& delims = { ',', '|', '\t', ';', '^', '~' });
    }
 
    std::vector<std::string> get_col_names(
        csv::string_view filename,
        const CSVFormat format = CSVFormat::guess_csv());
 
    CSVGuessResult guess_format(csv::string_view filename,
        const std::vector<char>& delims = { ',', '|', '\t', ';', '^', '~' });
 
    class CSVReader {
    public:
        class iterator {
        public:
            #ifndef DOXYGEN_SHOULD_SKIP_THIS
            using value_type = CSVRow;
            using difference_type = std::ptrdiff_t;
            using pointer = CSVRow * ;
            using reference = CSVRow & ;
            using iterator_category = std::input_iterator_tag;
            #endif
 
            iterator() = default;
            iterator(CSVReader* reader) : daddy(reader) {};
            iterator(CSVReader*, CSVRow&&);
 
            CONSTEXPR_14 reference operator*() { return this->row; }
 
            CONSTEXPR_14 pointer operator->() { return &(this->row); }
 
            iterator& operator++();   
            iterator operator++(int); 
            iterator& operator--();
 
            CONSTEXPR bool operator==(const iterator& other) const noexcept {
                return (this->daddy == other.daddy) && (this->i == other.i);
            }
 
            CONSTEXPR bool operator!=(const iterator& other) const noexcept { return !operator==(other); }
        private:
            CSVReader * daddy = nullptr;  // Pointer to parent
            CSVRow row;                   // Current row
            size_t i = 0;               // Index of current row
        };
 
        CSVReader(csv::string_view filename, CSVFormat format = CSVFormat::guess_csv());
 
        template<typename TStream,
            csv::enable_if_t<std::is_base_of<std::istream, TStream>::value, int> = 0>
        CSVReader(TStream& source, CSVFormat format = CSVFormat()) : _format(format) {
            using Parser = internals::StreamParser<TStream>;
 
            if (!format.col_names.empty())
                this->set_col_names(format.col_names);
 
            this->parser = std::unique_ptr<Parser>(
                new Parser(source, format, col_names)); // For C++11
            this->initial_read();
        }
 
        CSVReader(const CSVReader&) = delete; // No copy constructor
        CSVReader(CSVReader&&) = default;     // Move constructor
        CSVReader& operator=(const CSVReader&) = delete; // No copy assignment
        CSVReader& operator=(CSVReader&& other) = default;
        ~CSVReader() {
            if (this->read_csv_worker.joinable()) {
                this->read_csv_worker.join();
            }
        }
 
        bool read_row(CSVRow &row);
        iterator begin();
        HEDLEY_CONST iterator end() const noexcept;
 
        bool eof() const noexcept { return this->parser->eof(); };
 
        CSVFormat get_format() const;
        std::vector<std::string> get_col_names() const;
        int index_of(csv::string_view col_name) const;
 
 
        CONSTEXPR bool empty() const noexcept { return this->n_rows() == 0; }
 
        CONSTEXPR size_t n_rows() const noexcept { return this->_n_rows; }
 
        bool utf8_bom() const noexcept { return this->parser->utf8_bom(); }
 
    protected:
        void set_col_names(const std::vector<std::string>&);
 
        CSVFormat _format;
 
 
        internals::ColNamesPtr col_names = std::make_shared<internals::ColNames>();
 
        std::unique_ptr<internals::IBasicCSVParser> parser = nullptr;
 
        std::unique_ptr<RowCollection> records{new RowCollection(100)};
 
        size_t n_cols = 0;  
        size_t _n_rows = 0; 
        bool read_csv(size_t bytes = internals::ITERATION_CHUNK_SIZE);
 
    private:
        bool header_trimmed = false;
 
        std::thread read_csv_worker; 
 
        void initial_read() {
            this->read_csv_worker = std::thread(&CSVReader::read_csv, this, internals::ITERATION_CHUNK_SIZE);
            this->read_csv_worker.join();
        }
 
        void trim_header();
    };
}