csv_row.hpp

Go to the documentation of this file.

 
#pragma once
#include <cmath>
#include <iterator>
#include <memory> // For CSVField
#include <limits> // For CSVField
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <sstream>
#include <vector>
 
#include "common.hpp"
#include "data_type.hpp"
#include "col_names.hpp"
 
namespace csv {
    namespace internals {
        class IBasicCSVParser;
 
        static const std::string ERROR_NAN = "Not a number.";
        static const std::string ERROR_OVERFLOW = "Overflow error.";
        static const std::string ERROR_FLOAT_TO_INT =
            "Attempted to convert a floating point value to an integral type.";
        static const std::string ERROR_NEG_TO_UNSIGNED = "Negative numbers cannot be converted to unsigned types.";
    
        std::string json_escape_string(csv::string_view s) noexcept;
 
        struct RawCSVField {
            RawCSVField() = default;
            RawCSVField(size_t _start, size_t _length, bool _double_quote = false) {
                start = _start;
                length = _length;
                has_double_quote = _double_quote;
            }
 
            size_t start;
 
            size_t length; 
 
            bool has_double_quote;
        };
 
        class CSVFieldList {
        public:
            CSVFieldList(size_t single_buffer_capacity = (size_t)(internals::PAGE_SIZE / sizeof(RawCSVField))) :
                _single_buffer_capacity(single_buffer_capacity) {
                this->allocate();
            }
 
            // No copy constructor
            CSVFieldList(const CSVFieldList& other) = delete;
 
            // CSVFieldArrays may be moved
            CSVFieldList(CSVFieldList&& other) :
                _single_buffer_capacity(other._single_buffer_capacity) {
                buffers = std::move(other.buffers);
                _current_buffer_size = other._current_buffer_size;
                _back = other._back;
            }
 
            ~CSVFieldList() {
                for (auto& buffer : buffers)
                    delete[] buffer;
            }
 
            template <class... Args>
            void emplace_back(Args&&... args) {
                if (this->_current_buffer_size == this->_single_buffer_capacity) {
                    this->allocate();
                }
 
                *(_back++) = RawCSVField(std::forward<Args>(args)...);
                _current_buffer_size++;
            }
 
            size_t size() const noexcept {
                return this->_current_buffer_size + ((this->buffers.size() - 1) * this->_single_buffer_capacity);
            }
 
            RawCSVField& operator[](size_t n) const;
 
        private:
            const size_t _single_buffer_capacity;
 
            std::vector<RawCSVField*> buffers = {};
 
            size_t _current_buffer_size = 0;
 
            RawCSVField* _back = nullptr;
 
            void allocate();
        };
 
 
        struct RawCSVData {
            std::shared_ptr<void> _data = nullptr;
            csv::string_view data = "";
 
            internals::CSVFieldList fields;
 
            std::unordered_set<size_t> has_double_quotes = {};
 
            // TODO: Consider replacing with a more thread-safe structure
            std::unordered_map<size_t, std::string> double_quote_fields = {};
 
            internals::ColNamesPtr col_names = nullptr;
            internals::ParseFlagMap parse_flags;
            internals::WhitespaceMap ws_flags;
        };
 
        using RawCSVDataPtr = std::shared_ptr<RawCSVData>;
    }
 
    class CSVField {
    public:
        constexpr explicit CSVField(csv::string_view _sv) noexcept : sv(_sv) { };
 
        operator std::string() const {
            return std::string("<CSVField> ") + std::string(this->sv);
        }
 
        template<typename T = std::string> T get() {
            IF_CONSTEXPR(std::is_arithmetic<T>::value) {
                // Note: this->type() also converts the CSV value to float
                if (this->type() <= DataType::CSV_STRING) {
                    throw std::runtime_error(internals::ERROR_NAN);
                }
            }
 
            IF_CONSTEXPR(std::is_integral<T>::value) {
                // Note: this->is_float() also converts the CSV value to float
                if (this->is_float()) {
                    throw std::runtime_error(internals::ERROR_FLOAT_TO_INT);
                }
 
                IF_CONSTEXPR(std::is_unsigned<T>::value) {
                    if (this->value < 0) {
                        throw std::runtime_error(internals::ERROR_NEG_TO_UNSIGNED);
                    }
                }
            }
 
            // Allow fallthrough from previous if branch
            IF_CONSTEXPR(!std::is_floating_point<T>::value) {
                IF_CONSTEXPR(std::is_unsigned<T>::value) {
                    // Quick hack to perform correct unsigned integer boundary checks
                    if (this->value > internals::get_uint_max<sizeof(T)>()) {
                        throw std::runtime_error(internals::ERROR_OVERFLOW);
                    }
                }
                else if (internals::type_num<T>() < this->_type) {
                    throw std::runtime_error(internals::ERROR_OVERFLOW);
                }
            }
 
            return static_cast<T>(this->value);
        }
 
        bool try_parse_hex(int& parsedValue);
 
        bool try_parse_decimal(long double& dVal, const char decimalSymbol = '.');
 
        template<typename T>
        CONSTEXPR_14 bool operator==(T other) const noexcept
        {
            static_assert(std::is_arithmetic<T>::value,
                "T should be a numeric value.");
 
            if (this->_type != DataType::UNKNOWN) {
                if (this->_type == DataType::CSV_STRING) {
                    return false;
                }
 
                return internals::is_equal(value, static_cast<long double>(other), 0.000001L);
            }
 
            long double out = 0;
            if (internals::data_type(this->sv, &out) == DataType::CSV_STRING) {
                return false;
            }
 
            return internals::is_equal(out, static_cast<long double>(other), 0.000001L);
        }
 
        CONSTEXPR csv::string_view get_sv() const noexcept { return this->sv; }
 
        CONSTEXPR_14 bool is_null() noexcept { return type() == DataType::CSV_NULL; }
 
        CONSTEXPR_14 bool is_str() noexcept { return type() == DataType::CSV_STRING; }
 
        CONSTEXPR_14 bool is_num() noexcept { return type() >= DataType::CSV_INT8; }
 
        CONSTEXPR_14 bool is_int() noexcept {
            return (type() >= DataType::CSV_INT8) && (type() <= DataType::CSV_INT64);
        }
 
        CONSTEXPR_14 bool is_float() noexcept { return type() == DataType::CSV_DOUBLE; };
 
        CONSTEXPR_14 DataType type() noexcept {
            this->get_value();
            return _type;
        }
 
    private:
        long double value = 0;    
        csv::string_view sv = ""; 
        DataType _type = DataType::UNKNOWN; 
        CONSTEXPR_14 void get_value() noexcept {
            /* Check to see if value has been cached previously, if not
             * evaluate it
             */
            if ((int)_type < 0) {
                this->_type = internals::data_type(this->sv, &this->value);
            }
        }
    };
 
    class CSVRow {
    public:
        friend internals::IBasicCSVParser;
 
        CSVRow() = default;
        
        CSVRow(internals::RawCSVDataPtr _data) : data(_data) {}
        CSVRow(internals::RawCSVDataPtr _data, size_t _data_start, size_t _field_bounds)
            : data(_data), data_start(_data_start), fields_start(_field_bounds) {}
 
        CONSTEXPR bool empty() const noexcept { return this->size() == 0; }
 
        CONSTEXPR size_t size() const noexcept { return row_length; }
 
        CSVField operator[](size_t n) const;
        CSVField operator[](const std::string&) const;
        std::string to_json(const std::vector<std::string>& subset = {}) const;
        std::string to_json_array(const std::vector<std::string>& subset = {}) const;
 
        std::vector<std::string> get_col_names() const {
            return this->data->col_names->get_col_names();
        }
 
        operator std::vector<std::string>() const;
 
        class iterator {
        public:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
            using value_type = CSVField;
            using difference_type = int;
            using pointer = std::shared_ptr<CSVField>;
            using reference = CSVField & ;
            using iterator_category = std::random_access_iterator_tag;
#endif
            iterator(const CSVRow*, int i);
 
            reference operator*() const;
            pointer operator->() const;
 
            iterator operator++(int);
            iterator& operator++();
            iterator operator--(int);
            iterator& operator--();
            iterator operator+(difference_type n) const;
            iterator operator-(difference_type n) const;
 
            CONSTEXPR bool operator==(const iterator& other) const noexcept {
                return this->i == other.i;
            };
 
            CONSTEXPR bool operator!=(const iterator& other) const noexcept { return !operator==(other); }
 
#ifndef NDEBUG
            friend CSVRow;
#endif
 
        private:
            const CSVRow * daddy = nullptr;            // Pointer to parent
            std::shared_ptr<CSVField> field = nullptr; // Current field pointed at
            int i = 0;                                 // Index of current field
        };
 
        using reverse_iterator = std::reverse_iterator<iterator>;
 
        iterator begin() const;
        iterator end() const noexcept;
        reverse_iterator rbegin() const noexcept;
        reverse_iterator rend() const;
 
    private:
        csv::string_view get_field(size_t index) const;
 
        internals::RawCSVDataPtr data;
 
        size_t data_start = 0;
 
        size_t fields_start = 0;
 
        size_t row_length = 0;
    };
 
#ifdef _MSC_VER
#pragma region CSVField::get Specializations
#endif
    template<>
    inline std::string CSVField::get<std::string>() {
        return std::string(this->sv);
    }
 
    template<>
    CONSTEXPR_14 csv::string_view CSVField::get<csv::string_view>() {
        return this->sv;
    }
 
    template<>
    CONSTEXPR_14 long double CSVField::get<long double>() {
        if (!is_num())
            throw std::runtime_error(internals::ERROR_NAN);
 
        return this->value;
    }
#ifdef _MSC_VER
#pragma endregion CSVField::get Specializations
#endif
 
    template<>
    CONSTEXPR bool CSVField::operator==(const char * other) const noexcept
    {
        return this->sv == other;
    }
 
    template<>
    CONSTEXPR bool CSVField::operator==(csv::string_view other) const noexcept
    {
        return this->sv == other;
    }
}
 
inline std::ostream& operator << (std::ostream& os, csv::CSVField const& value) {
    os << std::string(value);
    return os;
}