XLXmlData.hpp

Go to the documentation of this file.

#ifndef OPENXLSX_XLXMLDATA_HPP
#define OPENXLSX_XLXMLDATA_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
 
// ===== External Includes ===== //
#include <cstdlib>
#include <memory>
#include <string>
 
// ===== OpenXLSX Includes ===== //
#include "OpenXLSX-Exports.hpp"
#include "XLContentTypes.hpp"
#include "XLXmlParser.hpp"
#include "XLXmlSavingDeclaration.hpp"
 
namespace OpenXLSX
{
    struct XLAllocatedMemory {
        void* data = nullptr;
        size_t size = 0;
 
        ~XLAllocatedMemory() { if (data) std::free(data); }
        XLAllocatedMemory() = default;
        
        // Disable copy
        XLAllocatedMemory(const XLAllocatedMemory&) = delete;
        XLAllocatedMemory& operator=(const XLAllocatedMemory&) = delete;
        
        // Enable move
        XLAllocatedMemory(XLAllocatedMemory&& other) noexcept : data(other.data), size(other.size) {
            other.data = nullptr;
            other.size = 0;
        }
        XLAllocatedMemory& operator=(XLAllocatedMemory&& other) noexcept {
            if (this != &other) {
                if (data) std::free(data);
                data = other.data;
                size = other.size;
                other.data = nullptr;
                other.size = 0;
            }
            return *this;
        }
 
        // Release ownership
        void* release() {
            void* ret = data;
            data = nullptr;
            return ret;
        }
    };
 
    class OPENXLSX_EXPORT XLXmlData final
    {
    public:
        // ===== PUBLIC MEMBER FUNCTIONS ===== //
 
        XLXmlData() = default;
 
        XLXmlData(XLDocument*        parentDoc,
                  const std::string& xmlPath,
                  const std::string& xmlId   = "",
                  XLContentType      xmlType = XLContentType::Unknown);
 
        ~XLXmlData();
 
        bool valid() const { return m_xmlDoc != nullptr; }
 
        XLXmlData(const XLXmlData& other) = delete;
 
        XLXmlData(XLXmlData&& other) noexcept = default;
 
        XLXmlData& operator=(const XLXmlData& other) = delete;
 
        XLXmlData& operator=(XLXmlData&& other) noexcept = default;
 
        void setRawData(const std::string& data);
 
        std::string getRawData(XLXmlSavingDeclaration savingDeclaration = XLXmlSavingDeclaration{}) const;
 
        XLAllocatedMemory getRawAllocatedData(XLXmlSavingDeclaration savingDeclaration = XLXmlSavingDeclaration{}) const;
 
        XLDocument* getParentDoc();
 
        const XLDocument* getParentDoc() const;
 
        std::string getXmlPath() const;
 
        std::string getXmlID() const;
 
        XLContentType getXmlType() const;
 
        XMLDocument* getXmlDocument();
 
        const XMLDocument* getXmlDocument() const;
 
        bool empty() const;
 
    private:
        // ===== PRIVATE MEMBER VARIABLES ===== //
 
        XLDocument*                          m_parentDoc{}; 
        std::string                          m_xmlPath{};   
        std::string                          m_xmlID{};     
        XLContentType                        m_xmlType{};   
        mutable std::unique_ptr<XMLDocument> m_xmlDoc;      
    public:
        bool        m_isStreamed{false};
        std::string m_streamFilePath;
    };
}    // 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_XLXMLDATA_HPP