Zip.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_UTIL__ZIP
#define COM_BORA_SOFTWARE__BALAU_UTIL__ZIP

#include <Balau/Exception/ResourceExceptions.hpp>
#include <Balau/Resource/File.hpp>
#include <Balau/Util/DateTime.hpp>
#include <Balau/Util/Files.hpp>

#include <boost/iostreams/categories.hpp>
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/copy.hpp>
#include <boost/iostreams/device/file_descriptor.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filtering_streambuf.hpp>

#include <algorithm>
#include <chrono>
#include <iosfwd>
#include <sstream>

namespace Balau {

namespace Resource::Impl {

class ZipEntrySource;
class ZipEntrySink;

} // namespace Resource::Impl

namespace Util {

struct ZipEntryInfo {
    std::string name;

    long long index;

    long long uncompressedSize;

    long long compressedSize;

    std::chrono::system_clock::time_point modificationTime;

    unsigned int crc;

    unsigned short compressionMethod;

    unsigned short encryptionMethod;
};

inline bool operator == (const ZipEntryInfo & lhs, const ZipEntryInfo & rhs) {
    return lhs.name == rhs.name
        && lhs.index == rhs.index
        && lhs.uncompressedSize == rhs.uncompressedSize
        && lhs.compressedSize == rhs.compressedSize
        && lhs.modificationTime == rhs.modificationTime
        && lhs.crc == rhs.crc
        && lhs.compressionMethod == rhs.compressionMethod
        && lhs.encryptionMethod == rhs.encryptionMethod;
}

template <typename AllocatorT>
inline U8String<AllocatorT> toString(const ZipEntryInfo & info) {
    return "{ " + Strings::join<AllocatorT>(
          ", "
        , info.name
        , info.index
        , info.uncompressedSize
        , info.compressedSize
        // TODO
//      , info.modificationTime
        , info.crc
        , info.compressionMethod
        , info.encryptionMethod
    ) + " }";
}

inline std::string toString(const ZipEntryInfo & info) {
    return "{ " + Strings::join(
          ", "
        , info.name
        , info.index
        , info.uncompressedSize
        , info.compressedSize
        // TODO
//      , info.modificationTime
        , info.crc
        , info.compressionMethod
        , info.encryptionMethod
    ) + " }";
}

class Unzipper {
    public: virtual void open(const Resource::File & path_, bool verify);

    public: virtual void open(const Resource::File & path_, bool verify, const std::string & pw);

    public: bool isOpen() const {
        return archive != nullptr;
    }

    public: Resource::File getPath() const {
        return path;
    }

    public: std::string readArchiveComment() const;

    public: long long entryCount() const;

    public: std::vector<std::string> entryNames() const;

    public: bool hasEntry(const std::string & name) const;

    public: long long getEntryIndex(const std::string & name) const;

    public: std::string getEntryName(long long index) const;

    public: void getEntryInfo(const std::string & name, ZipEntryInfo & info) const;

    public: void getEntryInfo(long long index, ZipEntryInfo & info) const;

    public: std::string readEntryComment(const std::string & name) const;

    public: std::string readEntryComment(long long index) const;

    public: std::vector<char> readEntryAsBytes(const std::string & name) const;

    public: std::vector<char> readEntryAsBytes(long long index) const;

    public: std::string readEntryAsString(const std::string & name) const;

    public: std::string readEntryAsString(long long index) const;

    public: virtual void close();

    public: virtual ~Unzipper();


    friend class Resource::Impl::ZipEntrySource;
    friend class Resource::Impl::ZipEntrySink;

    private: std::vector<char> readEntryAsBytesImpl(const ZipEntryInfo & info, const std::string & name) const;
    private: std::string readEntryAsStringImpl(const ZipEntryInfo & info, const std::string & name) const;

    // Used in the cleanUpName method.
    protected: enum class EntryType {
        Directory, File, Either
    };

    protected: void openImpl(const Resource::File & path_, bool verify, const std::string & pw, int mode);

    // Clean up the supplied name's separator characters.
    protected: std::string cleanUpName(const std::string & name, EntryType entryType) const;

    protected: long long getEntryIndexClean(const std::string & cleanName) const;
    protected: void throwZipException(const std::string & errorMessage) const;

    protected: void * archive;
    protected: Resource::File path;
};

class Zipper : public Unzipper {
    public: void open(const Resource::File & path_, bool verify) override;

    public: void open(const Resource::File & path_, bool verify, const std::string & pw) override;

    public: void putArchiveComment(const std::string & text);

    public: void deleteComment();

    public: void putDirectory(const std::string & name);

    public: void putEntry(const std::string & name, const Resource::File & bytes);

    public: void putEntry(const std::string & name, const std::vector<char> & bytes);

    public: void putEntry(const std::string & name, const std::string & bytes);

    public: void renameEntry(const std::string & name, const std::string & newName);

    public: void deleteEntry(const std::string & name);

    public: void close() override;

    public: void commit();


    // Common implementation for putEntry methods.
    private: template <typename SourceFunctionT> void putEntry(const std::string & name, SourceFunctionT getSource);

    // Rename a directory entry and all its descendants.
    private: void renameDirectory(const std::string & cleanName, const std::string & newCleanName);

    // Rename a file entry.
    private: void renameFile(const std::string & cleanName, const std::string & newCleanName);

    // Delete a directory entry and all its descendants.
    private: void deleteDirectory(const std::string & cleanName);

    // Delete a file entry.
    private: void deleteFile(const std::string & cleanName);
};

} // namespace Util

} // namespace Balau

#endif // COM_BORA_SOFTWARE__BALAU_UTIL__ZIP