RCF - Interprocess Communication for C++

//*****************************************************************************
// RCF - Remote Call Framework
// Copyright (c) 2005. All rights reserved.
// Developed by Jarl Lindrud.
// Contact: jlindrud@hotmail.com .
//*****************************************************************************

#ifndef INCLUDE_RCF_ZLIBCOMPRESSIONFILTER_HPP
#define INCLUDE_RCF_ZLIBCOMPRESSIONFILTER_HPP

#include <memory>
#include <vector>

#include <boost/noncopyable.hpp>

#include <RCF/AsyncFilter.hpp>

namespace RCF {

    static const int RCF_FILTER_ZLIB_COMPRESSION_STATELESS = 3;

    static const int RCF_FILTER_ZLIB_COMPRESSION_STATEFUL = 4;

    class ZlibCompressionFilter : public IdentityFilter, boost::noncopyable
    {
    public:
        ZlibCompressionFilter(int bufferSize, bool stateful);
        static const int DefaultBufferSize = 4096;

    private:
        void read(char *buffer, std::size_t bufferLen);
        void write(const char *buffer, std::size_t bufferLen);
        void onReadWriteCompleted(std::size_t bytesTransferred, int error);

        enum IoState
        {
            Ready,
            Reading,
            Writing
        };

        // input state
        IoState preState;

        friend class ZlibCompressionReadFilter;
        friend class ZlibCompressionWriteFilter;

        boost::shared_ptr<ZlibCompressionReadFilter> readFilter;
        boost::shared_ptr<ZlibCompressionWriteFilter> writeFilter;
    };

    /// Filter implementing a stateless compression protocol, through the Zlib library.
    class ZlibStatelessCompressionFilter : public ZlibCompressionFilter
    {
    public:
        /// Constructor.
        /// \param bufferSize Internal buffer size, limiting how much data can be compressed/decompressed in a single operation.
        ZlibStatelessCompressionFilter(int bufferSize = ZlibCompressionFilter::DefaultBufferSize) :
            ZlibCompressionFilter(bufferSize, false)
        {}

        static FilterDescription sGetFilterDescription();
        FilterDescription getFilterDescription() const;
    };

    /// Filter implementing a stateful compression protocol, through the Zlib library.
    class ZlibStatefulCompressionFilter : public ZlibCompressionFilter
    {
    public:
        /// Constructor.
        /// \param bufferSize Internal buffer size, limiting how much data can be compressed/decompressed in a single operation.
        ZlibStatefulCompressionFilter(int bufferSize = ZlibCompressionFilter::DefaultBufferSize) :
            ZlibCompressionFilter(bufferSize, true)
        {}

        static FilterDescription sGetFilterDescription();
        FilterDescription getFilterDescription() const;
    };

    
    /// Filter factory for ZlibStatelessCompressionFilter.
    class ZlibStatelessCompressionFilterFactory : public FilterFactory
    {
    public:
        /// Constructor.
        /// \param bufferSize Internal buffer size, limiting how much data can be compressed/decompressed in a single operation.
        ZlibStatelessCompressionFilterFactory(int bufferSize = ZlibCompressionFilter::DefaultBufferSize);
        FilterPtr createFilter();
        FilterDescription getFilterDescription();

    private:
        int bufferSize;
    };

    /// Filter factory for ZlibStatefulCompressionFilter.
    class ZlibStatefulCompressionFilterFactory : public FilterFactory
    {
    public:
        /// Constructor.
        /// \param bufferSize Internal buffer size, limiting how much data can be compressed/decompressed in a single operation.
        ZlibStatefulCompressionFilterFactory(int bufferSize = ZlibCompressionFilter::DefaultBufferSize);
        FilterPtr createFilter();
        FilterDescription getFilterDescription();

    private:
        int bufferSize;
    };

} // namespace RCF

#endif // ! INCLUDE_RCF_ZLIBCOMPRESSIONFILTER_HPP