raw_csv_data.hpp

Go to the documentation of this file.

 
#pragma once
#include <cassert>
#include <memory>
#if !defined(CSV_ENABLE_THREADS) || CSV_ENABLE_THREADS
#include <mutex>
#endif
#include <unordered_map>
#include <string>
#include <vector>
 
#include "common.hpp"
#include "col_names.hpp"
 
namespace csv {
    namespace internals {
        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) {
                const size_t max_fields = internals::ITERATION_CHUNK_SIZE + 1;
                _block_capacity = (max_fields + _single_buffer_capacity - 1) / _single_buffer_capacity;
                _blocks = std::unique_ptr<RawCSVField*[]>(new RawCSVField*[_block_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),
                _block_capacity(other._block_capacity) {
 
                this->_blocks = std::move(other._blocks);
                this->_owned_blocks = std::move(other._owned_blocks);
                _current_buffer_size = other._current_buffer_size;
                _current_block = other._current_block;
 
                // Recalculate _back pointer to point into OUR blocks, not the moved-from ones
                if (this->_blocks) {
                    RawCSVField* block = this->_blocks[_current_block];
                    _back = block ? (block + _current_buffer_size) : nullptr;
                } else {
                    _back = nullptr;
                }
 
                // Invalidate moved-from state to prevent use-after-move bugs
                other._back = nullptr;
                other._current_buffer_size = 0;
                other._current_block = 0;
                other._block_capacity = 0;
            }
 
            template <class... Args>
            void emplace_back(Args&&... args) {
                if (this->_current_buffer_size == this->_single_buffer_capacity) {
                    this->allocate();
                }
 
                assert(_back != nullptr);
                *(_back++) = RawCSVField(std::forward<Args>(args)...);
                _current_buffer_size++;
            }
 
            size_t size() const noexcept {
                return this->_current_buffer_size + (_current_block * this->_single_buffer_capacity);
            }
 
            RawCSVField& operator[](size_t n) const;
 
        private:
            const size_t _single_buffer_capacity;
 
            std::unique_ptr<RawCSVField*[]> _blocks = nullptr;
 
            std::vector<std::unique_ptr<RawCSVField[]>> _owned_blocks = {};
            // _owned_blocks may reallocate, but RawCSVField[] allocations stay put;
            // _blocks holds raw pointers to those allocations, so readers remain valid.
 
            size_t _current_buffer_size = 0;
 
            size_t _current_block = 0;
 
            size_t _block_capacity = 0;
 
            RawCSVField* _back = nullptr;
 
            void allocate();
        };
 
        struct RawCSVData {
            std::shared_ptr<void> _data = nullptr;
            csv::string_view data = "";
 
            internals::CSVFieldList fields;
 
            std::unordered_map<size_t, std::string> double_quote_fields = {};
#if CSV_ENABLE_THREADS
            mutable std::mutex double_quote_init_lock;  
#endif
 
            internals::ColNamesPtr col_names = nullptr;
            internals::ParseFlagMap parse_flags;
            internals::WhitespaceMap ws_flags;
        };
 
        using RawCSVDataPtr = std::shared_ptr<RawCSVData>;
    }
}