csv_format.hpp

Go to the documentation of this file.

 
#pragma once
#include <iterator>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "common.hpp"
#include "csv_exceptions.hpp"
 
namespace csv {
    namespace internals {
        template<typename RowSink, typename ParsePolicy, typename FieldPolicy, typename RowPolicy>
        class CSVParserCore;
        namespace parser {
            class CSVParserDriverBase;
        }
    }
 
    class CSVReader;
 
    enum class VariableColumnPolicy {
        THROW = -1,
        IGNORE_ROW = 0,
        KEEP   = 1,
        KEEP_NON_EMPTY = 2
    };
 
    enum class ColumnNamePolicy {
        EXACT = 0,            
        CASE_INSENSITIVE = 1  
    };
 
    struct CSVGuessResult {
        char delim;
        int header_row;
        size_t n_cols;
    };
 
    class CSVFormat {
    public:
        CSVFormat() = default;
 
        CSVFormat& delimiter(char delim);
 
        CSVFormat& delimiter(const std::vector<char> & delim);
 
        CSVFormat& trim(const std::vector<char> & ws);
 
        CSVFormat& quote(char quote);
 
        CSVFormat& column_names(const std::vector<std::string>& names);
 
        CSVFormat& header_row(int row);
 
        CSVFormat& no_header() {
            this->header_row(-1);
            return *this;
        }
 
        CSVFormat& quote(bool use_quote) {
            this->no_quote = !use_quote;
            return *this;
        }
 
        CONSTEXPR_14 CSVFormat& variable_columns(VariableColumnPolicy policy = VariableColumnPolicy::IGNORE_ROW) {
            this->variable_column_policy = policy;
            return *this;
        }
 
        CONSTEXPR_14 CSVFormat& variable_columns(bool policy) {
            this->variable_column_policy = (VariableColumnPolicy)policy;
            return *this;
        }
 
        CONSTEXPR_14 CSVFormat& column_names_policy(ColumnNamePolicy policy) {
            this->_column_name_policy = policy;
            return *this;
        }
 
        CSVFormat& chunk_size(size_t size);
 
        CONSTEXPR_14 CSVFormat& threading(bool enabled = true) {
            this->_threading = enabled;
            return *this;
        }
 
        CONSTEXPR_14 CSVFormat& speculative_parallel_threads(size_t n_threads) {
            this->_speculative_parallel_threads = n_threads;
            return *this;
        }
 
        CONSTEXPR_14 CSVFormat& speculative_parallel_min_bytes(size_t bytes) {
            this->_speculative_parallel_min_bytes = bytes;
            return *this;
        }
 
        CONSTEXPR_14 CSVFormat& eager_field_classification(bool enabled = true) {
            this->_eager_field_classification = enabled;
            return *this;
        }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
        char get_delim() const {
            // This error should never be received by end users.
            if (this->possible_delimiters.size() > 1) {
                throw std::runtime_error(internals::ERROR_MULTIPLE_DELIMITERS);
            }
 
            return this->possible_delimiters.at(0);
        }
 
        CONSTEXPR bool is_quoting_enabled() const { return !this->no_quote; }
        CONSTEXPR char get_quote_char() const { return this->quote_char; }
        CONSTEXPR int get_header() const { return this->header; }
        std::vector<char> get_possible_delims() const { return this->possible_delimiters; }
        std::vector<char> get_trim_chars() const { return this->trim_chars; }
        const std::vector<std::string>& get_col_names() const { return this->col_names; }
        CONSTEXPR VariableColumnPolicy get_variable_column_policy() const { return this->variable_column_policy; }
        CONSTEXPR ColumnNamePolicy get_column_name_policy() const { return this->_column_name_policy; }
        CONSTEXPR size_t get_chunk_size() const { return this->_chunk_size; }
        CONSTEXPR bool is_threading_enabled() const {
#if CSV_ENABLE_THREADS
            return this->_threading;
#else
            return false;
#endif
        }
        CONSTEXPR size_t get_speculative_parallel_threads() const { return this->_speculative_parallel_threads; }
        CONSTEXPR size_t get_speculative_parallel_min_bytes() const { return this->_speculative_parallel_min_bytes; }
        CONSTEXPR bool is_eager_field_classification_enabled() const { return this->_eager_field_classification; }
        CONSTEXPR bool should_use_speculative_parallel(size_t source_size, size_t n_threads) const {
#if CSV_ENABLE_THREADS
            return this->_threading
                && n_threads > 1
                && source_size >= this->_speculative_parallel_min_bytes;
#else
            (void)source_size;
            (void)n_threads;
            return false;
#endif
        }
#endif
        
        CSV_INLINE static CSVFormat guess_csv() {
            CSVFormat format;
            format.delimiter({ ',', '|', '\t', ';', '^' })
                .quote('"');
            // Assign header directly rather than via header_row() so that
            // header_explicitly_set_ remains false — the guesser must be free
            // to detect the real header row at construction time.
            format.header = 0;
 
            return format;
        }
 
        bool guess_delim() const {
            return this->possible_delimiters.size() > 1;
        }
 
        friend CSVReader;
        template<typename RowSink, typename ParsePolicy, typename FieldPolicy, typename RowPolicy>
        friend class internals::CSVParserCore;
        friend internals::parser::CSVParserDriverBase;
        
    private:
        void assert_no_char_overlap();
 
        std::vector<char> possible_delimiters = { ',' };
 
        std::vector<char> trim_chars = {};
 
        int header = 0;
 
        bool header_explicitly_set_ = false;
 
        bool no_quote = false;
 
        char quote_char = '"';
 
        std::vector<std::string> col_names = {};
 
        bool col_names_explicitly_set_ = false;
 
        VariableColumnPolicy variable_column_policy = VariableColumnPolicy::IGNORE_ROW;
 
        ColumnNamePolicy _column_name_policy = ColumnNamePolicy::EXACT;
 
        size_t _chunk_size = internals::CSV_CHUNK_SIZE_DEFAULT;
 
        bool _threading = true;
 
        size_t _speculative_parallel_threads = 0;
 
        size_t _speculative_parallel_min_bytes = internals::CSV_SPECULATIVE_PARALLEL_MIN_BYTES;
 
        bool _eager_field_classification = false;
    };
}