react-native-nitro-xlsx 0.2.5 → 0.2.6

package/thirdparty/OpenXLSX/Examples/external/CustomZip/CustomZip.hpp

@@ -0,0 +1,256 @@
+//
+// Created by Kenneth Balslev on 18/04/2022.
+//
+
+#ifndef OPENXLSX_CUSTOMZIP_HPP
+#define OPENXLSX_CUSTOMZIP_HPP
+
+#include <cstring>
+#include <fstream>
+#include <list>
+#include <zip.h>
+#ifdef ENABLE_NOWIDE
+    #include <nowide/cstdio.hpp>    // nowide::fopen, nowide::remove, nowide::rename
+    namespace boost {}        // ensure that namespace exists, even if boost doesn't define it
+    using namespace boost;    // depending on library version, nowide namespace is hidden in boost::nowide
+#else
+    #include <cstdio>       // std::fopen
+    #include <filesystem>   // std::filesystem::remove, std::filesystem::rename
+#endif
+#include <memory>
+#include <random>
+#include <string>
+
+class CustomZip
+{
+public:
+    /**
+     * @brief
+     */
+    CustomZip() : m_zipHandle(nullptr) {};
+
+    /**
+     * @brief
+     * @param other
+     */
+    CustomZip(const CustomZip& other) = default;
+
+    /**
+     * @brief
+     * @param other
+     */
+    CustomZip(CustomZip&& other) noexcept = default;
+
+    /**
+     * @brief
+     */
+    ~CustomZip() = default;
+
+    /**
+     * @brief
+     * @param other
+     * @return
+     */
+    CustomZip& operator=(const CustomZip& other) = default;
+
+    /**
+     * @brief
+     * @param other
+     * @return
+     */
+    CustomZip& operator=(CustomZip&& other) noexcept = default;
+
+    /**
+     * @brief
+     * @return
+     */
+    explicit operator bool() const { return isValid(); };
+
+    /**
+     *
+     * @return
+     */
+    bool isValid() const { return isOpen(); }
+
+    /**
+     * @brief
+     * @return
+     */
+    inline bool isOpen() const { return m_zipHandle != nullptr; }
+
+    /**
+     * @brief
+     * @param fileName
+     */
+    void open(const std::string& fileName)
+    {
+        // ===== If a file is already open, close (discard) it.
+        if (isOpen()) close();
+
+        // ===== Generate name for the temporary file.
+        const int NAME_LENGTH = 20;
+        m_fileName = fileName;
+        m_tempName = m_fileName.substr(0, m_fileName.rfind('/') + 1) + GenerateRandomName(NAME_LENGTH);
+
+        // ===== Copy the contents of the file to open, to the temporary file.
+        std::ifstream src(m_fileName, std::ios::binary);
+        std::ofstream dst(m_tempName, std::ios::binary);
+        dst << src.rdbuf();
+        src.close();
+        dst.close();
+
+        // ===== Open the temporary zip file
+        int errorFlag = 0;
+        m_zipHandle = zip_open(m_tempName.c_str(), ZIP_CREATE, &errorFlag);
+    }
+
+    /**
+     * @brief
+     */
+    void close()
+    {
+        // ===== If the file is open, discard changes and set the handle to nullptr.
+        if (isOpen()) {
+            zip_discard(m_zipHandle);
+            m_zipHandle = nullptr;
+        }
+
+        // ===== Delete the temporary file.
+#       ifdef ENABLE_NOWIDE
+            nowide::remove(m_tempName.c_str());    // NOLINT
+#       else
+            std::filesystem::remove(m_tempName.c_str());
+#       endif
+    }
+
+    /**
+     * @brief make archive updates (from addEntry) available to calls via getEntry
+     */
+    void commitChanges() {} // no-op for CustomZip
+
+    /**
+     * @brief
+     * @param path
+     */
+    void save(const std::string& path = "")
+    {
+        // ===== Discard any changes made since last commit;
+        if (isOpen()) {
+            zip_discard(m_zipHandle);
+            m_zipHandle = nullptr;
+        }
+
+        // ===== Delete the original file, and rename the temporary file to that of the original.
+        if (!path.empty()) m_fileName = path;
+#       ifdef ENABLE_NOWIDE
+            nowide::remove(m_fileName.c_str());                        // NOLINT
+            nowide::rename(m_tempName.c_str(), m_fileName.c_str());    // NOLINT
+#       else
+            std::filesystem::remove(m_fileName.c_str());
+            std::filesystem::rename(m_tempName.c_str(), m_fileName.c_str());
+#       endif
+
+        // ===== Reopen the file.
+        open(m_fileName);
+    }
+
+    /**
+     * @brief
+     * @param name
+     * @param data
+     */
+    void addEntry(const std::string& name, const std::string& data)
+    {
+        // ===== Create a buffer with the data and immediately commit it to the zip file.
+        zip_source_t* source = zip_source_buffer(m_zipHandle, data.data(), data.size(), false);
+        zip_file_add(m_zipHandle, name.c_str(), source, ZIP_FL_OVERWRITE | ZIP_FL_ENC_GUESS);
+
+        // ===== Commit the change to the temporary archive (this is safer and - surprisingly - faster than committing everything at once)
+        zip_close(m_zipHandle);
+        int errorFlag = 0;
+        m_zipHandle   = zip_open(m_tempName.c_str(), ZIP_CREATE, &errorFlag);
+    }
+
+    /**
+     * @brief like addEntry, but call commitChanges() afterwards
+     * @param name
+     * @param data
+     */
+    void addEntryAndCommit(const std::string& name, const std::string& data)
+    {
+        addEntry(name, data);
+        commitChanges();       // ensure that entry name is directly available for calls to getEntry
+    }
+
+    /**
+     * @brief
+     * @param entryName
+     */
+    void deleteEntry(const std::string& entryName) {
+        if (hasEntry(entryName)) {
+            zip_stat_t stat;
+            zip_stat(m_zipHandle, entryName.c_str(), ZIP_FL_ENC_GUESS, &stat);
+            zip_delete(m_zipHandle, stat.index);
+        }
+    }
+
+    /**
+     * @brief
+     * @param name
+     * @return
+     */
+    std::string getEntry(const std::string& name) {
+
+        // ===== Create the output string and open the file in the zip archive.
+        std::string result;
+        std::unique_ptr<zip_file_t, decltype(&zip_fclose)> zipFile(zip_fopen(m_zipHandle, name.c_str(), ZIP_FL_ENC_GUESS), &zip_fclose);
+
+        // ===== Access the file data and copy the data to the output string.
+        if (zipFile) {
+            zip_stat_t stat;
+            zip_stat(m_zipHandle, name.c_str(), ZIP_FL_ENC_GUESS, &stat);
+
+            auto data = std::unique_ptr<char[]>(new char[stat.size + 1]);
+            zip_fread(zipFile.get(), data.get(), stat.size);
+            data[stat.size] = '\0';
+            result = data.get();
+        }
+
+        return result;
+    }
+
+    /**
+     * @brief
+     * @param entryName
+     * @return
+     */
+    bool hasEntry(const std::string& entryName) const {
+
+        // ===== If the index of the entryName is higher than zero, it means that an entry with that name exists in the archive.
+        auto index = zip_name_locate(m_zipHandle, entryName.c_str(), ZIP_FL_ENC_GUESS);
+        return index >= 0;
+    }
+
+private:
+    inline std::string GenerateRandomName(int length)
+    {
+        std::string letters = "abcdefghijklmnopqrstuvwxyz0123456789"; // NOLINT
+
+        std::random_device                 rand_dev;
+        std::mt19937                       generator(rand_dev());
+        std::uniform_int_distribution<int> distr(0, letters.size() - 1);
+
+        std::string result;
+        for (int i = 0; i < length; ++i) {
+            result += letters[distr(generator)];
+        }
+
+        return result + ".tmp";
+    }
+
+    zip* m_zipHandle = nullptr;
+    std::string          m_fileName;
+    std::string          m_tempName;
+};
+
+#endif    // OPENXLSX_CUSTOMZIP_HPP

package/thirdparty/OpenXLSX/LICENSE.md

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, Kenneth Troldal Balslev
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.