soa/logger/compressor.h

/* compressor.h                                                    -*- C++ -*-
   Jeremy Barnes, 19 September 2012
   Copyright (c) 2012 Datacratic.  All rights reserved.

   Interface to a compressor object.

   We prefer this to other solutions as we have full control over when a
   stream is flushed and we can use this to minimise the potential for
   data loss.

   It would be nice to use boost::iostreams for this, but their flush() is
   buggy and there is no way to have precise control over flushing.
*/

#ifndef __logger__compressor_h__
#define __logger__compressor_h__


#include <memory>
#include <functional>
#include <string>

namespace Datacratic {


/*****************************************************************************/
/* COMPRESSOR                                                                */
/*****************************************************************************/

struct Compressor {

    virtual ~Compressor();

    typedef std::function<size_t (const char * data, size_t len)> OnData;

    OnData onData;

    enum FlushLevel {
        FLUSH_NONE,     
        FLUSH_AVAILABLE,
        FLUSH_SYNC,     
        FLUSH_RESTART,  
    };

    virtual size_t compress(const char * data, size_t len,
                            const OnData & onData) = 0;
    
    virtual size_t flush(FlushLevel flushLevel, const OnData & onData) = 0;

    virtual size_t finish(const OnData & onData) = 0;

    static std::string filenameToCompression(const std::string & filename);

    static Compressor * create(const std::string & compression,
                               int level);
};


/*****************************************************************************/
/* NULL COMPRESSOR                                                           */
/*****************************************************************************/

struct NullCompressor : public Compressor {

    NullCompressor();

    virtual ~NullCompressor();

    virtual size_t compress(const char * data, size_t len,
                            const OnData & onData);
    
    virtual size_t flush(FlushLevel flushLevel, const OnData & onData);

    virtual size_t finish(const OnData & onData);
};

/*****************************************************************************/
/* GZIP COMPRESSOR                                                           */
/*****************************************************************************/

struct GzipCompressor : public Compressor {

    GzipCompressor(int level);

    virtual ~GzipCompressor();

    void open(int level);

    virtual size_t compress(const char * data, size_t len,
                            const OnData & onData);
    
    virtual size_t flush(FlushLevel flushLevel, const OnData & onData);

    virtual size_t finish(const OnData & onData);

private:
    struct Itl;
    std::unique_ptr<Itl> itl;
};

/*****************************************************************************/
/* LZMA COMPRESSOR                                                           */
/*****************************************************************************/

struct LzmaCompressor : public Compressor {

    LzmaCompressor();

    ~LzmaCompressor();

    virtual size_t compress(const char * data, size_t len,
                            const OnData & onData);
    
    virtual size_t flush(FlushLevel flushLevel, const OnData & onData);

    virtual size_t finish(const OnData & onData);

private:
    struct Itl;
    std::unique_ptr<Itl> itl;
};

} // namespace Datacratic

#endif /* __logger__compressor_h__ */