csv_row.hpp

Go to the documentation of this file.

 
#pragma once
#include <cmath>
#include <iterator>
#include <memory> // For CSVField
#include <limits> // For CSVField
#if !defined(CSV_ENABLE_THREADS) || CSV_ENABLE_THREADS
#include <mutex>
#endif
#include <unordered_set>
#include <string>
#include <sstream>
#include <vector>
 
#include "common.hpp"
#ifdef CSV_HAS_CXX20
#include <ranges>
#endif
#include "data_type.hpp"
#include "parse_hex.hpp"
#include "raw_csv_data.hpp"
 
#if CSV_ENABLE_THREADS
#define CSV_INIT_WITH_OPTIONAL_DCL(data_ref, value_ref, ...) \
    do { \
        if ((value_ref).empty()) { \
            std::lock_guard<std::mutex> lock((data_ref).double_quote_init_lock); \
            if ((value_ref).empty()) { \
                __VA_ARGS__ \
            } \
        } \
    } while (0)
#else
#define CSV_INIT_WITH_OPTIONAL_DCL(data_ref, value_ref, ...) \
    do { \
        (void)(data_ref); \
        if ((value_ref).empty()) { \
            __VA_ARGS__ \
        } \
    } while (0)
#endif
 
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;
 
        // Inside CSVField::get() or wherever you materialize the value
        csv::string_view get_trimmed(csv::string_view sv, const WhitespaceMap& ws_flags) noexcept;
    }
 
    class CSVField {
    public:
        constexpr explicit CSVField(csv::string_view _sv) noexcept : sv(_sv) {}
 
        operator csv::string_view() const noexcept {
            return this->sv;
        }
 
        operator std::string() const {
            return std::string(this->sv);
        }
 
        template<typename T = std::string> T get() {
            T out{};
            if (const auto* err = check_convert(out)) throw std::runtime_error(err);
            return out;
        }
 
        template<typename T = std::string>
        bool try_get(T& out) noexcept {
            return check_convert(out) == nullptr;
        }
 
        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; 
        template<typename T>
        const char* check_convert(T& out) noexcept {
            IF_CONSTEXPR(std::is_arithmetic<T>::value) {
                if (this->type() <= DataType::CSV_STRING)
                    return internals::ERROR_NAN.c_str();
            }
 
            IF_CONSTEXPR(std::is_integral<T>::value) {
                if (this->is_float())
                    return internals::ERROR_FLOAT_TO_INT.c_str();
 
                IF_CONSTEXPR(std::is_unsigned<T>::value) {
                    if (this->value < 0)
                        return internals::ERROR_NEG_TO_UNSIGNED.c_str();
                }
            }
 
            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 internals::ERROR_OVERFLOW.c_str();
                }
                else if (internals::type_num<T>() < this->_type) {
                    return internals::ERROR_OVERFLOW.c_str();
                }
            }
 
            out = static_cast<T>(this->value);
            return nullptr;
        }
 
        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[](csv::string_view) 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;
 
        #ifdef CSV_HAS_CXX20
        auto to_sv_range() const {
            return std::views::iota(size_t{0}, this->size())
                | std::views::transform([this](size_t i) { return this->get_field(i); });
        }
        #endif
 
        operator std::vector<std::string>() const;
 
        csv::string_view raw_str() const noexcept;
 
        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, field.length);
 
            if (field.has_double_quote) {
                auto& value = _data->double_quote_fields[field_index];
                CSV_INIT_WITH_OPTIONAL_DCL((*_data), value,
                    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];
                    }
                );
 
                if (_data->has_ws_trimming)
                    return internals::get_trimmed(csv::string_view(value), _data->ws_flags);
                return value;
            }
            else if (_data->has_ws_trimming) {
                field_str = internals::get_trimmed(field_str, _data->ws_flags);
            }
 
            return field_str;
        }
 
        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;
    }
}
 
#undef CSV_INIT_WITH_OPTIONAL_DCL