CompressionPackageDesign: tango-archive-stuff.d

module compression;

/**
 * tango.compression.model.ICompressionCodec
 */

import tango.io.model.IConduit;
import tango.io.protocol.model.IReader;
import tango.io.protocol.model.IWriter;

/**
 * CompressionProfile provides an abstract way of setting up compression
 * settings without having to worry about the concrete details.
 */
enum CompressionProfile
{
    Normal = 1, /// Average level compression.
    Fast = 0,   /// As fast as possible: may omit compression altogether.
    Small = 2   /// As small as possible.
}

interface ICompressionCodec : IConduitFilter
{
    /**
     * These two functions provide a way to serialise the codec state
     * necessary to exactly reproduce its behaviour.  For instance, this could
     * be used to write out the precise profile used to compress a stream of
     * data, thus allowing it to be decompressed again.
     */
    abstract void readProfile(IReader input);
    abstract void writeProfile(IWriter output); /// ditto

    /**
     * These two functions access the abstract profile setting, which means
     * people don't have to stuff around with the above two if they don't have
     * the need.
     */
    abstract CompressionProfile getProfile();
    abstract void setProfile(CompressionProfile profile); /// ditto
}

/**
 * tango.compression.ZLib
 */

//import tango.io.model.IConduit : IConduitFilter;
//import tango.compression.model.ICompressionCodec;

class ZLib : ICompressionCodec
{
    protected IConduitFilter next;

    private
    {
        CompressionProfile profile_;
        int level_; // = ???  There's a default constant somewhere...
        z_stream zs;
        bool inited = false;
    }

    this()
    {
        this(CompressionProfile.init);
    }

    this(CompressionProfile profile)
    {
        this.profile = profile;
    }

    this(int level)
    {
        this.level = level;
    }

    uint reader(void[] dst)
    {
    }

    uint writer(void[] src)
    {
        if( src.length == 0 )
            // You never know what weird stuff people will do :p
            return next.writer(src);

        if( !inited )
            initZlib();

        // Create a new buffer for the compressed data to live in, and tell
        // zlib where it is.  Also important is to make sure that the buffer
        // is deleted once we leave this function.
        ubyte[] destbuf = new ubyte[zs.avail_in + src.length];
        scope(exit) delete destbuf;
        zs.next_out = destbuf.ptr;
        zs.avail_out = destbuf.length;

        if( zs.avail_in )
            // If there is already some data ready to be compressed, then we
            // need to prepend that to our source data.
            src = zs.next_in[0 .. zs.avail_in] ~ src;

        // Tell zlib where the input data lives.
        zs.next_in = src.ptr;
        zs.avail_in = src.length;

        // Ok, compress that data; compress it good.
        auto err = deflate(&zs, Z_NO_FLUSH);
        if( err != Z_STREAM_END && err != Z_OK )
            // Uh-oh; something went horribly, horribly wrong.
            zerror(err);

        // We truncate the output buffer since zlib may not have used all the
        // space we allocated; zs.avail_out is the number of bytes it didn't
        // use.
        destbuf = destbuf[0 .. $-zs.avail_out]
        destbuf.length = destbuf.length - zs.avail_out;

        // Ok; our original data is now compressed.  We just need to feed that
        // to the next filter in the chain.
        return next.writer(destbuf);
    }

    int level()
    {
        return level_;
    }

    int level(int level_)
    {
        if( inited )
            throw new Exception("Cannot change compression settings"
                    " after (de)compression has begun!");
        this.level_ = level_;
        return level_;
    }

    CompressionProfile profile()
    {
        return profile_;
    }

    CompressionProfile profile(CompressionProfile profile_)
    {
        switch( profile_ )
        {
            /+case CompressionProfile.None:
                level = Z_NO_COMPRESSION;
                break;+/

            case CompressionProfile.Fast:
                level = Z_BEST_SPEED;
                break;

            case CompressionProfile.Normal:
                level = Z_DEFAULT_COMPRESSION;
                break;

            case CompressionProfile.Small:
                level = Z_BEST_COMPRESSION;
                break;

            default:
                throw new Exception("Invalid compression profile.");
        }

        return profile_;
    }

    void readProfile(IReader input)
    {
        if( inited )
            throw new Exception("Cannot change compression settings"
                    " after (de)compression has begun!");

        int level_;
        
        input.get (level_);
        level = level_;
    }

    void writeProfile(IWriter output)
    {
        output.put (level);
    }

    void bind(IConduit conduit, IConduitFilter next)
    {
        this.next = next;
    }

    void unbind()
    {
    }

    private void initZlib()
    {
        //
    }
}