zipper.hh

//  Copyright (C) 2011 Michael McMaster <michael@codesrc.com>
//
//  This file is part of libzipper.
//
//  libzipper 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.
//
//  libzipper 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 libzipper.  If not, see <http://www.gnu.org/licenses/>.

#ifndef zipper_hh
#define zipper_hh

#include <stdexcept>
#include <memory>
#include <string>
#include <vector>

#include <cstdint>

#include <sys/stat.h> // For mode_t
#include <sys/time.h> // For timeval



namespace zipper
{
    typedef uint64_t zsize_t;

    enum ContainerFormat
    {
        Container_begin = 0,

        Container_none = 0,

        Container_zip,

        Container_gzip,

        Container_end
    };

    struct Container
    {
        enum CapabilityBits
        {
            Compression = 1,

            Decompression = 2,

            EmbeddedFilenames = 4,

            Archive = 8,

            FileSize = 16
        };

        ContainerFormat format;

        std::string mediaType;

        uint32_t capabilities;
    };

    extern const timeval s_now;

    const Container& getContainer(ContainerFormat format);

    class Exception : public std::runtime_error
    {
    public:
        Exception(const std::string& what);
    };

    class FormatException : public Exception
    {
    public:
        FormatException(const std::string& what);
    };

    class IOException : public Exception
    {
    public:
        IOException(const std::string& what);
    };

    class UnsupportedException : public Exception
    {
    public:
        UnsupportedException(const std::string& what);
    };

    class Reader
    {
    public:
        virtual ~Reader();

        virtual const std::string& getSourceName() const = 0;

        virtual const timeval& getModTime() const = 0;

        virtual zsize_t getSize() const = 0;

        virtual void readData(
            zsize_t offset, zsize_t bytes, uint8_t* dest
            ) const = 0;

    };

    class FileReader : public Reader
    {
    public:
        FileReader(const std::string& filename);

        FileReader(const std::string& filename, int fd, bool closeFd);

        virtual ~FileReader();

        virtual const std::string& getSourceName() const;

        virtual const timeval& getModTime() const;

        virtual zsize_t getSize() const;

        virtual void readData(
            zsize_t offset, zsize_t bytes, uint8_t* dest
            ) const;
    private:
        FileReader(const FileReader&);
        FileReader& operator=(const FileReader&);

        class FileReaderImpl;
        FileReaderImpl* m_impl;
    };

    typedef std::shared_ptr<Reader> ReaderPtr;

    class Writer
    {
    public:
        virtual ~Writer();

        virtual zsize_t getSize() const = 0;

        virtual void writeData(
            zsize_t offset, zsize_t bytes, const uint8_t* data
            ) = 0;
    };

    typedef std::shared_ptr<Writer> WriterPtr;

    class FileWriter : public Writer
    {
    public:
        FileWriter(
            const std::string& filename,
            mode_t createPermissions = 0664,
            const timeval& modTime = s_now);

        FileWriter(const std::string& filename, int fd, bool closeFd);

        virtual ~FileWriter();

        virtual zsize_t getSize() const;

        virtual void writeData(
            zsize_t offset, zsize_t bytes, const uint8_t* data
            );
    private:
        FileWriter(const FileWriter&);
        FileWriter& operator=(const FileWriter&);

        class FileWriterImpl;
        FileWriterImpl* m_impl;
    };

    class CompressedFile
    {
    public:
        virtual ~CompressedFile();

        virtual bool isDecompressSupported() const = 0;

        virtual void decompress(Writer& writer) = 0;

        virtual const std::string& getPath() const = 0;

        virtual zsize_t getCompressedSize() const = 0;

        virtual zsize_t getUncompressedSize() const = 0;

        virtual const timeval& getModificationTime() const = 0;
    };
    typedef std::shared_ptr<CompressedFile> CompressedFilePtr;

    class Decompressor
    {
    public:
        Decompressor(const ReaderPtr& reader);

        Decompressor(Reader& reader);

        ~Decompressor();

        ContainerFormat getContainerFormat() const;

        std::vector<CompressedFilePtr> getEntries() const;
    private:
        Decompressor(const Decompressor&);
        Decompressor& operator=(const Decompressor&);

        class DecompressorImpl;
        DecompressorImpl* m_decompressor;
    };

    class Compressor
    {
    public:
        Compressor(ContainerFormat format, const WriterPtr& writer);

        Compressor(ContainerFormat format, Writer& writer);

        ~Compressor();

        void addFile(const Reader& reader);

        class CompressorImpl;
    private:
        Compressor(const Compressor&);
        Compressor& operator=(const Compressor&);

        CompressorImpl* m_compressor;
    };
}

#endif