csv_format.hpp

Go to the documentation of this file.

 
#pragma once
#include <iterator>
#include <stdexcept>
#include <string>
#include <vector>
 
#include "common.hpp"
 
namespace csv {
    namespace internals {
        class IBasicCSVParser;
    }
 
    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);
 
        #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("There is more than one possible delimiter.");
            }
 
            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; }
        #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;
        friend internals::IBasicCSVParser;
        
    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;
    };
}