XLSharedStrings.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLSHAREDSTRINGS_HPP
#define OPENXLSX_XLSHAREDSTRINGS_HPP
 
#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
#    pragma warning(push)
#    pragma warning(disable : 4251)
#    pragma warning(disable : 4275)
#endif    // _MSC_VER
 
#include <deque>
#include <functional>      // std::reference_wrapper
#include <limits>          // std::numeric_limits
#include <ostream>         // std::basic_ostream
#include <shared_mutex>    // std::shared_mutex
#include <string>
#include <ankerl/unordered_dense.h> // O(1) ankerl::unordered_dense string lookup
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLStringArena.hpp"
#include "XLXmlData.hpp"
#include "XLXmlFile.hpp"
#include <string_view>
#include <vector>
 
namespace OpenXLSX
{
    struct StringViewHash {
        using is_transparent = void;
        auto operator()(std::string_view str) const noexcept -> uint64_t {
            return ankerl::unordered_dense::hash<std::string_view>{}(str);
        }
    };
 
    // Alias for flat hash map to allow easy substitution in the future
    template<typename Key, typename Value>
    using FlatHashMap = ankerl::unordered_dense::map<Key, Value, StringViewHash, std::equal_to<>>;
 
    constexpr size_t XLMaxSharedStrings = (std::numeric_limits<int32_t>::max)();    // pull request #261: wrapped max in parentheses to
                                                                                    // prevent expansion of windows.h "max" macro
 
    struct XLSharedStringsState {
        XLStringArena                               arena{};
        std::vector<std::string_view>               cache{};
        FlatHashMap<std::string_view, int32_t>      index{};
        std::unique_ptr<std::shared_mutex>          mutex{std::make_unique<std::shared_mutex>()};
 
        void clear() {
            arena.clear();
            cache.clear();
            index.clear();
            // mutex remains intact
        }
    };
 
    class XLSharedStrings;    // forward declaration
    typedef std::reference_wrapper<const XLSharedStrings> XLSharedStringsRef;
 
    extern const XLSharedStrings
        XLSharedStringsDefaulted;    // to be used for default initialization of all references of type XLSharedStrings
 
    class OPENXLSX_EXPORT XLSharedStrings : public XLXmlFile
    {
        //---------- Friend Declarations ----------//
        friend class XLDocument;    // for access to protected function rewriteXmlFromCache
 
        //----------------------------------------------------------------------------------------------------------------------
        //           Public Member Functions
        //----------------------------------------------------------------------------------------------------------------------
 
    public:
        XLSharedStrings() = default;
 
        explicit XLSharedStrings(XLXmlData*            xmlData,
                                 XLSharedStringsState* state);
 
        ~XLSharedStrings();
 
        XLSharedStrings(const XLSharedStrings& other) = default;
 
        XLSharedStrings(XLSharedStrings&& other) noexcept = default;
 
        XLSharedStrings& operator=(const XLSharedStrings& other) = default;
 
        XLSharedStrings& operator=(XLSharedStrings&& other) noexcept = default;
 
        int32_t stringCount() const
        {
            if (!m_state) return 0;
            if (m_state->mutex) {
                std::shared_lock<std::shared_mutex> lock(*m_state->mutex);
                return static_cast<int32_t>(m_state->cache.size());
            }
            return static_cast<int32_t>(m_state->cache.size());
        }
 
        int32_t getStringIndex(std::string_view str) const;
 
        bool stringExists(std::string_view str) const;
 
        const char* getString(int32_t index) const;
 
        std::string_view getStringView(int32_t index) const;
 
        int32_t appendString(std::string_view str) const;
 
        void reserveStrings(size_t n) const;
 
        size_t memoryUsageBytes() const noexcept;
 
        int32_t getOrCreateStringIndex(std::string_view str) const;
 
        void clearString(int32_t index) const;
 
        void print(std::basic_ostream<char>& ostr) const;
 
    protected:
        int32_t rewriteXmlFromCache();
 
        XLAllocatedMemory generateRawAllocatedSstXml() const;
 
        void rebuild(const std::vector<int32_t>& indexMap, int32_t newStringCount);
 
    private:
        XLSharedStringsState* m_state{}; 
        mutable bool m_domDirty{false};
    };
}    // namespace OpenXLSX
 
#ifdef _MSC_VER    // conditionally enable MSVC specific pragmas to avoid other compilers warning about unknown pragmas
#    pragma warning(pop)
#endif    // _MSC_VER
 
#endif    // OPENXLSX_XLSHAREDSTRINGS_HPP