ZipEntry.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_ENTRY
#define COM_BORA_SOFTWARE__BALAU_RESOURCE__ZIP_ENTRY

#include <Balau/Resource/ZipEntryByteReadResource.hpp>
#include <Balau/Resource/ZipEntryUtf8To32ReadResource.hpp>
#include <Balau/Resource/UriComponents.hpp>
#include <Balau/Util/Files.hpp>

namespace Balau::Resource {

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

    public: std::unique_ptr<Uri> append(const std::string & pathComponent) const override {
        ThrowBalauException(Exception::UnsupportedOperationException, "ZipEntry 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;
        }

        if (Util::Strings::startsWith(str, "/")) {
            // Absolute path.
            return std::unique_ptr<Uri>(new ZipEntry(archive, archive.getEntryIndex(str)));
        } else {
            // Relative path.
            const std::string entryName = archive.getEntryName(entryIndex);
            const std::string normalisedName = UriComponents::normalizePath(entryName);
            const auto newName = normalisedName + str;
            return std::unique_ptr<Uri>(new ZipEntry(archive, archive.getEntryIndex(newName)));
        }
    }

    public: std::string toUriString() const override;

    public: std::string toRawString() const override {
        return toUriString();
    }

    public: bool isEntryDirectory() const;

    public: bool isEntryFile() const;

    public: std::string name() const {
        return archive.getEntryName(entryIndex);
    }

    public: size_t size() const;

    public: std::string readEntryComment() const {
        return archive.readEntryComment(entryIndex);
    }

    public: std::vector<char> readEntryAsBytes() const {
        return archive.readEntryAsBytes(entryIndex);
    }

    public: std::string readEntryAsString() const {
        return archive.readEntryAsString(entryIndex);
    }

    public: size_t hashcode() const noexcept override;

    public: bool operator == (const Uri & rhs) const override;

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

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

    public: ZipEntryByteReadResource getByteReadResource() const {
        return ZipEntryByteReadResource(*this);
    }

    public: ZipEntryUtf8To32ReadResource getUtf8To32ReadResource() const {
        return ZipEntryUtf8To32ReadResource(*this);
    }

    public: std::unique_ptr<ByteReadResource> byteReadResource() const override {
        return std::unique_ptr<ByteReadResource>(new ZipEntryByteReadResource(*this));
    }

    public: std::unique_ptr<Utf8To32ReadResource> utf8To32ReadResource() const override {
        return std::unique_ptr<Utf8To32ReadResource>(new ZipEntryUtf8To32ReadResource(*this));
    }

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

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

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

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

    public: std::unique_ptr<RecursiveUriIterator> recursiveIterator() const override {
        ThrowBalauException(Exception::NotImplementedException, "Zip entry URIs do not have recursive iterators.");
    }

    public: std::unique_ptr<UriIterator> iterator() const override {
        ThrowBalauException(Exception::NotImplementedException, "Zip entry URIs do not have iterators.");
    }

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

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

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


    friend class ZipFile;
    friend class ZipEntryByteReadResource;
    friend class ZipEntryUtf8To32ReadResource;

    private: ZipEntry(Util::Unzipper & archive_, long long entryIndex_)
        : archive(archive_)
        , entryIndex(entryIndex_) {}

    private: Util::Unzipper & archive;
    private: long long entryIndex;
};

} // namespace Balau::Resource

#endif // COM_BORA_SOFTWARE__BALAU_RESOURCE__ZIP_ENTRY