ZipArchive.hpp

Go to the documentation of this file.

/*
 *
 * ---
 *
 *  Copyright (C) 2020 Anselm Schmidt (ans[ät]ohai.su)
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version in addition to the terms of any
 *  licences already herein identified.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 *
 * ZipArchive.hpp
 *
 * Wrapper for pointer to a libzip archive.
 *  Does NOT have ownership of the pointer, but takes care of its deletion!
 *
 *  Created on: Jan 4, 2021
 *      Author: ans
 */

#ifndef WRAPPER_ZIPARCHIVE_HPP_
#define WRAPPER_ZIPARCHIVE_HPP_

#include "ZipSource.hpp"

#include <zip.h>

#include <string>   // std::string

namespace crawlservpp::Wrapper {

    /*
     * DECLARATION
     */


    class ZipArchive {
    public:

        ZipArchive();
        virtual ~ZipArchive();


        [[nodiscard]] struct zip * get() noexcept;
        [[nodiscard]] const struct zip * getc() const noexcept;
        [[nodiscard]] bool valid() const noexcept;
        [[nodiscard]] std::string getError();


        bool addEmptyDirectory(const std::string& name);

        bool addFile(
                const std::string& fileName,
                const std::string& content,
                bool overwrite
        );


        void close() noexcept;
        void close(std::string& dumpTo);



        ZipArchive(ZipArchive&) = delete;

        ZipArchive& operator=(ZipArchive&) = delete;

        ZipArchive(ZipArchive&& other) noexcept;
        ZipArchive& operator=(ZipArchive&& other) noexcept;


    private:
        // underlying source
        ZipSource source;

        // underlying pointer to ZIP archive
        struct zip * ptr{nullptr};

        // last occured error
        zip_error_t error{};

        // internal static helper function
        static void copyError(const zip_error_t * from, zip_error_t& to);
    };

    /*
     * IMPLEMENTATION
     */

    /*
     * CONSTRUCTION AND DESTRUCTION
     */

    inline ZipArchive::ZipArchive() {
        // check whether empty source has been created
        if(!(this->source.valid())) {
            this->error = this->source.getError();

            return;
        }

        // create archive from empty source
        this->ptr = zip_open_from_source(this->source.get(), ZIP_TRUNCATE, &(this->error));

        if(this->ptr != nullptr) {
            // keep the source (to be cleared by its wrapper)
            zip_source_keep(this->source.get());
        }
    }

    inline ZipArchive::~ZipArchive() {
        this->close();
    }

    /*
     * GETTERS
     */


    inline struct zip * ZipArchive::get() noexcept {
        return this->ptr;
    }


    inline const struct zip * ZipArchive::getc() const noexcept {
        return this->ptr;
    }


    inline bool ZipArchive::valid() const noexcept {
        return this->ptr != nullptr;
    }


    inline std::string ZipArchive::getError() {
        return zip_error_strerror(&(this->error));
    }

    /*
     * ARCHIVE FUNCTIONALITY
     */


    inline bool ZipArchive::addEmptyDirectory(const std::string& name) {
        if(this->ptr == nullptr) {
            return false;
        }

        const auto result{
            zip_add_dir(this->ptr, name.c_str())
        };

        if(result < 0) {
            // copy error from archive
            ZipArchive::copyError(
                    zip_get_error(this->ptr),
                    this->error
            );

            return false;
        }

        return true;
    }


    inline bool ZipArchive::addFile(
            const std::string& name,
            const std::string& content,
            bool overwrite
    ) {
        if(this->ptr == nullptr) {
            return false;
        }

        ZipSource fileSource(content.data(), content.size());

        // keep the source (to be cleared by its wrapper)
        zip_source_keep(fileSource.get());

        const auto result{
            zip_file_add(
                    this->ptr,
                    name.c_str(),
                    fileSource.get(),
                    ZIP_FL_ENC_UTF_8 | (overwrite ? ZIP_FL_OVERWRITE : 0)
            )
        };

        if(result < 0) {
            // decrement reference count as it has not been used on error
            zip_source_free(fileSource.get());

            ZipArchive::copyError(zip_get_error(this->ptr), this->error);

            return false;
        }

        return true;
    }

    /*
     * CLEANUP
     */


    inline void ZipArchive::close() noexcept {
        if(this->ptr != nullptr) {
            zip_close(this->ptr);

            this->ptr = nullptr;
        }

        zip_error_fini(&(this->error));
    }


    inline void ZipArchive::close(std::string& dumpTo) {
        if(this->ptr == nullptr) {
            return;
        }

        this->close();

        if(this->source.valid()) {
            zip_source_open(this->source.get());

            zip_source_seek(this->source.get(), 0, SEEK_END);

            const zip_int64_t size{
                zip_source_tell(this->source.get())
            };

            zip_source_seek(this->source.get(), 0, SEEK_SET);

            dumpTo.resize(size);

            zip_source_read(
                    this->source.get(),
                    static_cast<void*>(dumpTo.data()),
                    size
            );
        }
    }

    /*
     * COPY AND MOVE
     */


    inline ZipArchive::ZipArchive(ZipArchive&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }


    inline ZipArchive& ZipArchive::operator=(ZipArchive&& other) noexcept {
        if(&other != this) {
            this->close();

            this->ptr = other.ptr;

            other.ptr = nullptr;
        }

        return *this;
    }

    /*
     * INTERNAL STATIC HELPER FUNCTION (private)
     */

    // copy error
    inline void ZipArchive::copyError(const zip_error_t * from, zip_error_t& to) {
        zip_error_fini(&to);
        zip_error_init(&to);

        to.sys_err = from->sys_err;
        to.zip_err = from->zip_err;
    }

} /* namespace crawlservpp::Wrapper */

#endif /* WRAPPER_ZIPARCHIVE_HPP_ */