ZipFile.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_RESOURCE__ZIP_FILE
#define COM_BORA_SOFTWARE__BALAU_RESOURCE__ZIP_FILE

#include <Balau/Resource/File.hpp>
#include <Balau/Resource/ZipEntry.hpp>

namespace Balau::Resource {

class ZipFile : public File {
    public: class RecursiveZipFileIterator {
        public: bool hasNext() const {
            return nextEntryIndex < entryCount;
        }

        public: ZipEntry next() {
            return ZipEntry(archive, nextEntryIndex++);
        }

        friend class ZipFile;

        private: RecursiveZipFileIterator(ZipFile & zipFile, bool verify, const std::string & pw)
            : nextEntryIndex(0) {
            archive.open(zipFile, verify, pw);

            if (!archive.isOpen()) {
                ThrowBalauException(
                    Exception::ZipException, "Could not open zip file for reading.", File(zipFile.entry)
                );
            }

            entryCount = archive.entryCount();
        }

        private: Util::Unzipper archive;
        private: long long nextEntryIndex;
        private: long long entryCount;
    };

    private: class RecursiveZipFileUriIterator : public RecursiveUriIterator {
        public: bool hasNext() const override {
            return nextEntryIndex < entryCount;
        }

        public: std::unique_ptr<Uri> next() override {
            return std::unique_ptr<Uri>(new ZipEntry(archive, nextEntryIndex++));
        }

        friend class ZipFile;

        private: RecursiveZipFileUriIterator(const ZipFile & zipFile, bool verify, const std::string & pw)
            : nextEntryIndex(0) {
            archive.open(zipFile, verify, pw);

            if (!archive.isOpen()) {
                ThrowBalauException(
                    Exception::ZipException, "Could not open zip file for reading.", File(zipFile.entry)
                );
            }

            entryCount = archive.entryCount();
        }

        private: Util::Unzipper archive;
        private: long long nextEntryIndex;
        private: long long entryCount;
    };

    public: class ZipFileIterator {
        public: bool hasNext() const {
            return nextEntryIndex < entryCount;
        }

        public: ZipEntry next() {
            return ZipEntry(archive, nextEntryIndex++);
        }

        friend class ZipFile;

        private: explicit ZipFileIterator(ZipFile & zipFile, bool verify, const std::string & pw)
            : nextEntryIndex(0) {
            ThrowBalauException(Exception::NotImplementedException, "ZipFileIterator");

            archive.open(zipFile, verify, pw);

            if (!archive.isOpen()) {
                ThrowBalauException(
                    Exception::ZipException, "Could not open zip file for reading.", File(zipFile.entry)
                );
            }

            entryCount = archive.entryCount();
        }

        private: Util::Unzipper archive;
        private: long long nextEntryIndex;
        private: long long entryCount;
    };

    // TODO not yet implemented
    private: class ZipFileUriIterator : public UriIterator {
        public: bool hasNext() const override {
            return nextEntryIndex < entryCount;
        }

        public: std::unique_ptr<Uri> next() override {
            return std::unique_ptr<Uri>(new ZipEntry(archive, nextEntryIndex++));
        }

        friend class ZipFile;

        private: ZipFileUriIterator(const ZipFile & zipFile, bool verify, const std::string & pw)
            : nextEntryIndex(0) {
            ThrowBalauException(Exception::NotImplementedException, "ZipFileUriIterator");

            archive.open(zipFile, verify, pw);

            if (!archive.isOpen()) {
                ThrowBalauException(
                    Exception::ZipException, "Could not open zip file for reading.", File(zipFile.entry)
                );
            }

            entryCount = archive.entryCount();
        }

        private: Util::Unzipper archive;
        private: long long nextEntryIndex;
        private: long long entryCount;
    };

    public: explicit ZipFile(File file_, std::string password_ = "")
        : File(std::move(file_))
        , password(std::move(password_)) {}

    public: ZipFile(const ZipFile & zipFile) = default;

    public: ZipFile(ZipFile && zipFile) noexcept
        : File(std::move(zipFile)) {}

    public: ZipFile & operator = (const ZipFile & zipFile) = default;

    public: ZipFile & operator = (ZipFile && zipFile) = default;

    public: std::unique_ptr<Uri> clone() const override {
        return std::unique_ptr<Uri>(new ZipFile(*this));
    }

    public: std::unique_ptr<Uri> append(const std::string & pathComponent) const override {
        ThrowBalauException(Exception::UnsupportedOperationException, "ZipFile does not support path appending.");
    }

    public: std::unique_ptr<Uri> resolve(std::string_view path) const override {
        static const std::regex scheme { "[a-zA-Z][a-zA-Z0-9+-\\.]*:" };

        auto cleanPath = Util::Strings::trim(path);
        auto str = std::string(cleanPath);

        if (Util::Strings::startsWithRegex(str, scheme)) {
            std::unique_ptr<Uri> uri;
            fromString(uri, str);
            return uri;
        }

        boost::filesystem::path p(str);

        if (p.is_relative()) {
            auto p2 = boost::filesystem::relative(p, entry.path());
            return std::unique_ptr<Uri>(new ZipFile(File(p2)));
        } else { // absolute
            return std::unique_ptr<Uri>(new ZipFile(File(p)));
        }
    }

    public: bool canReadFrom() const override {
        return false;
    }

    public: bool canWriteTo() const override {
        return false;
    }

    public: std::unique_ptr<ByteReadResource> byteReadResource() const override {
        ThrowBalauException(Exception::UnsupportedOperationException, "ZipFile URIs do not have a byte read resource.");
    }

    public: std::unique_ptr<Utf8To32ReadResource> utf8To32ReadResource() const override {
        ThrowBalauException(Exception::UnsupportedOperationException, "ZipFile URIs do not have a Unicode read resource.");
    }

    public: std::unique_ptr<ByteWriteResource> byteWriteResource() override {
        ThrowBalauException(Exception::UnsupportedOperationException, "ZipFile URIs do not have a byte write resource.");
    }

    public: std::unique_ptr<Utf32To8WriteResource> utf32To8WriteResource() override {
        ThrowBalauException(Exception::UnsupportedOperationException, "ZipFile URIs do not have a Unicode write resource.");
    }

    public: bool isRecursivelyIterable() const override {
        return true;
    }

    public: bool isIterable() const override {
        return true;
    }

    public: std::unique_ptr<RecursiveUriIterator> recursiveIterator() const override {
        return std::unique_ptr<RecursiveUriIterator>(new RecursiveZipFileUriIterator(*this, false, ""));
    }

    public: std::unique_ptr<UriIterator> iterator() const override {
        return std::unique_ptr<UriIterator>(new ZipFileUriIterator(*this, false, ""));
    }

    public: RecursiveZipFileIterator recursiveZipFileIterator(bool verify = false, const std::string & pw = "") {
        return RecursiveZipFileIterator(*this, verify, pw);
    }

    public: ZipFileIterator zipFileIterator(bool verify = false, const std::string & pw = "") {
        return ZipFileIterator(*this, verify, pw);
    }

    public: RecursiveFileIterator recursiveFileIterator() const override {
        ThrowBalauException(Exception::UnsupportedOperationException, "ZipFile URIs do not have recursive file iterators.");
    }

    public: FileIterator fileIterator() const override {
        ThrowBalauException(Exception::UnsupportedOperationException, "ZipFile URIs do not have file iterators.");
    }

    public: bool operator == (const Uri & rhs) const override {
        const auto * o = dynamic_cast<const ZipFile *>(&rhs);
        return o == nullptr ? false : getEntry() == o->getEntry();
    }

    public: bool isRegularDirectory() const override {
        return false;
    }

    public: bool isRegularFile() const override {
        return true;
    }

    public: void dispatch(UriDispatcher & dispatcher) const override {
        dispatcher.dispatch(*this);
    }


    private: std::string password;
};

template <typename AllocatorT>
inline Balau::U8String<AllocatorT> toString(const ZipFile & zipFile) {
    return zipFile.toRawString<AllocatorT>();
}

inline std::string toString(const ZipFile & zipFile) {
    return zipFile.toRawString();
}

} // namespace Balau::Resource

namespace std { // NOLINT

template <> struct hash<Balau::Resource::ZipFile> {
    size_t operator () (const Balau::Resource::ZipFile & zipFile) const noexcept {
        return zipFile.hashcode();
    }
};

template <> struct equal_to<Balau::Resource::ZipFile> {
    bool operator () (const Balau::Resource::ZipFile & lhs, const Balau::Resource::ZipFile & rhs) const {
        return lhs == rhs;
    }
};

} // namespace std

#endif // COM_BORA_SOFTWARE__BALAU_RESOURCE__ZIP_FILE