XLStringArena.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLSTRINGARENA_HPP
#define OPENXLSX_XLSTRINGARENA_HPP
 
#include <algorithm>
#include <cstdint>
#include <memory>
#include <string_view>
#include <vector>
 
namespace OpenXLSX
{
 
    class XLStringArena
    {
    public:
        // Default block size: 4 MB accommodates many short strings without fragmentation.
        explicit XLStringArena(size_t blockSize = 4 * 1024 * 1024) : m_blockSize(blockSize), m_currentOffset(blockSize) {}
 
        // Disable copy — string_view pointers would dangle after a copy
        XLStringArena(const XLStringArena&)            = delete;
        XLStringArena& operator=(const XLStringArena&) = delete;
 
        XLStringArena(XLStringArena&&) noexcept            = default;
        XLStringArena& operator=(XLStringArena&&) noexcept = default;
 
        [[nodiscard]] std::string_view store(std::string_view str)
        {
            if (str.empty()) {
                static constexpr char emptyStr[] = "";
                return {emptyStr, 0};
            }
 
            const size_t needed = str.size() + 1;    // +1 for null terminator
 
            if (m_currentOffset + needed > blockCapacity()) {
                // Try to reuse a free block, otherwise allocate a new one
                const size_t allocSize = std::max(m_blockSize, needed);
                if (!m_freeBlocks.empty() && m_freeBlocks.back().capacity >= allocSize) {
                    m_activeBlocks.push_back(std::move(m_freeBlocks.back()));
                    m_freeBlocks.pop_back();
                }
                else {
                    m_activeBlocks.push_back({std::make_unique<char[]>(allocSize), allocSize});
                }
                m_currentOffset = 0;
            }
 
            char* dest = m_activeBlocks.back().data.get() + m_currentOffset;
            std::copy(str.begin(), str.end(), dest);
            dest[str.size()] = '\0';
 
            m_currentOffset += needed;
            return {dest, str.size()};
        }
 
        void clear() noexcept
        {
            for (auto& blk : m_activeBlocks) m_freeBlocks.push_back(std::move(blk));
            m_activeBlocks.clear();
            m_currentOffset = m_blockSize;    // force new-block allocation on next store
        }
 
        void reset() noexcept
        {
            m_activeBlocks.clear();
            m_freeBlocks.clear();
            m_currentOffset = m_blockSize;
        }
 
        [[nodiscard]] size_t capacity() const noexcept
        {
            size_t total = 0;
            for (const auto& blk : m_activeBlocks) total += blk.capacity;
            return total;
        }
 
        [[nodiscard]] size_t used() const noexcept { return m_currentOffset; }
 
    private:
        struct Block
        {
            std::unique_ptr<char[]> data;
            size_t                  capacity{0};
        };
 
        [[nodiscard]] size_t blockCapacity() const noexcept { return m_activeBlocks.empty() ? 0 : m_activeBlocks.back().capacity; }
 
        size_t             m_blockSize;        // target size for new blocks
        size_t             m_currentOffset;    // write position within the current active block
        std::vector<Block> m_activeBlocks;     // currently in-use blocks
        std::vector<Block> m_freeBlocks;       // recycled blocks awaiting reuse
    };
 
}    // namespace OpenXLSX
 
#endif    // OPENXLSX_XLSTRINGARENA_HPP