csv_reader.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <algorithm>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iterator>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
#include "common.hpp"
#include "csv_exceptions.hpp"
#include "data_type.hpp"
#include "csv_format.hpp"
#include "parser/mmap.hpp"
#include "parser/scheduler.hpp"
#include "parser/stream.hpp"
 
namespace csv {
    class CSVReader {
    public:
#if CSV_EXCEPTIONS_ENABLED
        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 reference operator*() const { return const_cast<reference>(this->row); }
 
            CONSTEXPR_14 pointer operator->() { return &(this->row); }
            CONSTEXPR_14 pointer operator->() const { return const_cast<pointer>(&(this->row)); }
 
            iterator& operator++();   
            iterator operator++(int); 
            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
        };
#endif
 
 
        static std::unique_ptr<CSVReader> try_open(
            csv::string_view filename, CSVError& error,
            const CSVFormat& format = CSVFormat::guess_csv());
 
        template<typename TStream,
            csv::enable_if_t<std::is_base_of<std::istream, TStream>::value, int> = 0>
        static std::unique_ptr<CSVReader> try_open(
            TStream& source, CSVError& error,
            const CSVFormat& format = CSVFormat::guess_csv()) {
            error.clear();
            std::unique_ptr<CSVReader> reader(new CSVReader(format, initialize_tag{}));
            reader->init_from_stream(source, format);
            error = reader->error_;
            return error ? nullptr : std::move(reader);
        }
 
        static std::unique_ptr<CSVReader> try_open(
            std::unique_ptr<std::istream> source, CSVError& error,
            const CSVFormat& format = CSVFormat::guess_csv());
 
#ifdef CSV_HAS_STD_EXPECTED
        template<typename Source>
        static std::expected<std::unique_ptr<CSVReader>, CSVError> try_open(
            Source&& source, const CSVFormat& format = CSVFormat::guess_csv()) {
            CSVError error;
            auto reader = try_open(std::forward<Source>(source), error, format);
            if (error) return std::unexpected(std::move(error));
            return reader;
        }
#endif
 
#if CSV_EXCEPTIONS_ENABLED
        CSVReader(csv::string_view filename, const CSVFormat& format = CSVFormat::guess_csv())
            : CSVReader(format, initialize_tag{}) {
            open_file(filename, format);
            internals::throw_error(error_);
        }
 
        template<typename TStream,
            csv::enable_if_t<std::is_base_of<std::istream, TStream>::value, int> = 0>
        CSVReader(TStream& source, const CSVFormat& format = CSVFormat::guess_csv())
            : CSVReader(format, initialize_tag{}) {
            init_from_stream(source, format);
            internals::throw_error(error_);
        }
 
        CSVReader(std::unique_ptr<std::istream> source,
            const CSVFormat& format = CSVFormat::guess_csv())
            : CSVReader(format, initialize_tag{}) {
            owned_stream = std::move(source);
            if (!owned_stream)
                throw std::invalid_argument(internals::ERROR_READER_NULL_STREAM);
            init_from_stream(*owned_stream, format);
            internals::throw_error(error_);
        }
#endif
 
        CSVReader(const CSVReader&) = delete;             
        CSVReader& operator=(const CSVReader&) = delete;  
 
        CSVReader(CSVReader&& other) noexcept :
            read_scheduler_(other._format.is_threading_enabled()) {
            other.read_scheduler_.join();
            this->move_state_from(other);
        }
 
        CSVReader& operator=(CSVReader&& other) noexcept {
            if (this == &other) {
                return *this;
            }
 
            this->read_scheduler_.join();
            other.read_scheduler_.join();
            this->move_state_from(other);
 
            return *this;
        }
 
        ~CSVReader() {
            this->read_scheduler_.join();
        }
 
 
#if CSV_EXCEPTIONS_ENABLED
        bool read_row(CSVRow &row);
#endif
        bool try_read_row(CSVRow& row, CSVError& error);
 
#if CSV_EXCEPTIONS_ENABLED
        bool read_chunk(std::vector<CSVRow>& out, size_t max_rows);
        iterator begin();
        CSV_CONST iterator end() const noexcept;
#endif
        bool try_read_chunk(std::vector<CSVRow>& out, size_t max_rows, CSVError& error);
 
        bool eof() const noexcept { return this->parser->eof(); }
 
 
        CSVFormat get_format() const;
 
        const std::vector<std::string>& get_col_names() const{
            static const std::vector<std::string> empty_col_names;
            return (this->col_names) ? this->col_names->get_col_names() : empty_col_names;
        }
 
        internals::ConstColNamesPtr col_names_ptr() const noexcept {
            return this->col_names;
        }
 
        int index_of(csv::string_view col_name) const {
            return this->col_names->index_of(col_name);
        }
 
 
        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(); }
 
        internals::SpeculativeParseDiagnostics speculative_diagnostics() const noexcept {
            return this->parser ? this->parser->speculative_diagnostics()
                : internals::SpeculativeParseDiagnostics();
        }
 
        size_t parse_worker_count() const noexcept {
            return this->parser ? this->parser->parse_worker_count() : 1;
        }
 
    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::parser::CSVParserDriverBase> parser = nullptr;
 
        std::unique_ptr<RowCollection> records{new RowCollection(100)};
 
        std::unique_ptr<std::istream> owned_stream = nullptr;
 
        size_t n_cols = 0;  
        size_t _n_rows = 0; 
        bool read_csv(size_t bytes = internals::CSV_CHUNK_SIZE_DEFAULT);
 
    private:
        struct initialize_tag {};
        CSVReader(const CSVFormat& format, initialize_tag)
            : _format(format), read_scheduler_(format.is_threading_enabled()) {}
        CSVError error_;
        void open_file(csv::string_view filename, const CSVFormat& format);
 
        bool header_trimmed = false;
 
        int header_rows_trimmed_ = 0;
        
        size_t _chunk_size = internals::CSV_CHUNK_SIZE_DEFAULT; 
        bool _read_requested = false; 
        internals::CSVReadScheduler read_scheduler_;
 
        void move_state_from(CSVReader& other) noexcept {
            this->_format = std::move(other._format);
            this->error_ = std::move(other.error_);
            this->col_names = std::move(other.col_names);
            this->parser = std::move(other.parser);
            this->records = std::move(other.records);
            this->owned_stream = std::move(other.owned_stream);
            this->n_cols = other.n_cols;
            this->_n_rows = other._n_rows;
            this->header_trimmed = other.header_trimmed;
            this->header_rows_trimmed_ = other.header_rows_trimmed_;
            this->_chunk_size = other._chunk_size;
            this->_read_requested = other._read_requested;
            this->read_scheduler_.set_threading_enabled(this->_format.is_threading_enabled());
            this->read_scheduler_.adopt_exception(other.read_scheduler_.take_exception());
            other.reset_after_move();
        }
 
        void reset_after_move() noexcept {
            this->n_cols = 0;
            this->_n_rows = 0;
            this->header_trimmed = false;
            this->header_rows_trimmed_ = 0;
            this->_read_requested = false;
            this->_chunk_size = internals::CSV_CHUNK_SIZE_DEFAULT;
        }
 
 
        void init_parser(std::unique_ptr<internals::parser::CSVParserDriverBase> parser);
 
        template<typename TStream,
            csv::enable_if_t<std::is_base_of<std::istream, TStream>::value, int> = 0>
        void init_from_stream(TStream& source, const CSVFormat& format) {
            this->init_parser(
                std::unique_ptr<internals::parser::CSVParserDriverBase>(
                    new internals::parser::StreamParser<TStream>(source, format, this->col_names)
                )
            );
        }
 
        void initial_read();
 
        void trim_header();
 
 
        bool accept_row(CSVRow&& candidate, CSVRow* single_row, std::vector<CSVRow>* batch_rows);
 
        bool check_for_rows();
 
        void drain_rows_into_chunk(std::vector<CSVRow>& out, size_t max_rows);
    };
 
    #if defined(CSV_HAS_CXX20) && CSV_EXCEPTIONS_ENABLED
    static_assert(
        internals::csv_write_rows_input_range<CSVReader>,
        "CSVReader must remain compatible with csv::DelimWriter::write_rows()."
    );
    #endif
}