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 <mutex>
#include <unordered_set>
#include <string>
#include <sstream>
#include <vector>
 
#include "common.hpp"
#include "data_type.hpp"
#include "parse_hex.hpp"
#include "raw_csv_data.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;
    }
 
    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);
        }
 
        template<typename T = std::string>
        bool try_get(T& out) noexcept {
            IF_CONSTEXPR(std::is_arithmetic<T>::value) {
                // Check if value is numeric
                if (this->type() <= DataType::CSV_STRING) {
                    return false;
                }
            }
 
            IF_CONSTEXPR(std::is_integral<T>::value) {
                // Check for float-to-int conversion
                if (this->is_float()) {
                    return false;
                }
 
                IF_CONSTEXPR(std::is_unsigned<T>::value) {
                    if (this->value < 0) {
                        return false;
                    }
                }
            }
 
            // Check for overflow
            IF_CONSTEXPR(!std::is_floating_point<T>::value) {
                IF_CONSTEXPR(std::is_unsigned<T>::value) {
                    if (this->value > internals::get_uint_max<sizeof(T)>()) {
                        return false;
                    }
                }
                else if (internals::type_num<T>() < this->_type) {
                    return false;
                }
            }
 
            out = static_cast<T>(this->value);
            return true;
        }
 
        template<typename T = long long>
        bool try_parse_hex(T& parsedValue) {
            static_assert(std::is_integral<T>::value,
                "try_parse_hex only works with integral types (int, long, long long, etc.)");
            return internals::try_parse_hex(this->sv, 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) {}
        CSVRow(internals::RawCSVDataPtr _data, size_t _data_start, size_t _field_bounds, size_t _row_length)
            : data(_data), data_start(_data_start), fields_start(_field_bounds), row_length(_row_length) {}
 
        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();
        }
 
        std::unordered_map<std::string, std::string> to_unordered_map() const;
 
        std::unordered_map<std::string, std::string> to_unordered_map(
            const std::vector<std::string>& subset
        ) const;
 
        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
            internals::RawCSVDataPtr data = nullptr;             // Keep data alive for lifetime of iterator
            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:
        inline csv::string_view get_field_impl(size_t index, const internals::RawCSVDataPtr& _data) const {
            using internals::ParseFlags;
 
            if (index >= this->size())
                throw std::runtime_error("Index out of bounds.");
 
            const size_t field_index = this->fields_start + index;
            auto field = _data->fields[field_index];
            auto field_str = csv::string_view(_data->data).substr(this->data_start + field.start);
 
            if (field.has_double_quote) {
                auto& value = _data->double_quote_fields[field_index];
                // Double-check locking: minimize lock contention by checking before acquiring lock
                if (value.empty()) {
                    std::lock_guard<std::mutex> lock(_data->double_quote_init_lock);
 
                    // Check again after acquiring lock in case another thread initialized it
                    if (value.empty()) {
                        bool prev_ch_quote = false;
                        for (size_t i = 0; i < field.length; i++) {
                            if (_data->parse_flags[field_str[i] + CHAR_OFFSET] == ParseFlags::QUOTE) {
                                if (prev_ch_quote) {
                                    prev_ch_quote = false;
                                    continue;
                                }
                                else {
                                    prev_ch_quote = true;
                                }
                            }
 
                            value += field_str[i];
                        }
                    }
                }
 
                return csv::string_view(value);
            }
 
            return field_str.substr(0, field.length);
        }
 
        csv::string_view get_field(size_t index) const;
 
        csv::string_view get_field_safe(size_t index, internals::RawCSVDataPtr _data) 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;
    }
 
    template<>
    inline bool CSVField::try_get<std::string>(std::string& out) noexcept {
        out = std::string(this->sv);
        return true;
    }
 
    template<>
    CONSTEXPR_14 bool CSVField::try_get<csv::string_view>(csv::string_view& out) noexcept {
        out = this->sv;
        return true;
    }
 
    template<>
    CONSTEXPR_14 bool CSVField::try_get<long double>(long double& out) noexcept {
        if (!is_num())
            return false;
 
        out = this->value;
        return true;
    }
#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;
}