gzfilterstream.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hidehisa Akiyama
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */
 
 
#ifndef RCSC_GZ_GZFILTERSTREAM_H
#define RCSC_GZ_GZFILTERSTREAM_H
 
#include <boost/scoped_ptr.hpp>
#include <iostream>
 
namespace rcsc {
 
 
class gzfilterstreambuf
    : public std::streambuf {
public:
    enum CompressionLevel {
        DEFAULT_COMPRESSION = 6,
        NO_COMPRESSION = 0,
        BEST_SPEED = 1,
        BEST_COMPRESSION = 9,
    };
 
    enum FlushType {
        NO_FLUSH = 0,
        PARTIAL_FLUSH  = 1, // will be removed, use SYNC_FLUSH instead
        SYNC_FLUSH = 2,
        FULL_FLUSH = 3,
        FINISH = 4
    };
 
private:
    std::streambuf & M_strmbuf;
    std::ostream * M_output_stream;
    std::istream * M_input_stream;
    std::streamsize M_buf_size;
    char_type * M_read_buf;
    char_type * M_input_buf;
    char_type * M_output_buf;
    char_type * M_write_buf;
 
    struct Impl;
 
    std::unique_ptr< Impl > M_impl;
    int M_level;
 
    gzfilterstreambuf( const gzfilterstreambuf & ) = delete;
    gzfilterstreambuf & operator=( const gzfilterstreambuf & ) = delete;
 
public:
 
    explicit
    gzfilterstreambuf( std::streambuf & strm,
                       int level = DEFAULT_COMPRESSION,
                       std::size_t buf_size = 8192 );
 
    ~gzfilterstreambuf();
 
    bool setLevel( const int level );
 
protected:
 
    bool writeData( int flush_type = NO_FLUSH );
 
    int readData( char * dest,
                  int & dest_size );
 
    virtual
    int_type overflow( int_type c );
 
    virtual
    int sync();
 
    virtual
    int_type underflow();
};
 
 
class gzfilterstream
    : public std::iostream {
private:
    gzfilterstreambuf M_filter_buf;
 
    gzfilterstream( const gzfilterstream & ) = delete;
    gzfilterstream & operator=( const gzfilterstream & ) = delete;
 
public:
    explicit
    gzfilterstream( std::streambuf & strmbuf,
                    int level = gzfilterstreambuf::DEFAULT_COMPRESSION,
                    std::size_t buf_size = 8192 );
 
    explicit
    gzfilterstream( std::iostream & strm,
                    int level = gzfilterstreambuf::DEFAULT_COMPRESSION,
                    std::size_t buf_size = 8192 );
 
    bool setLevel( const int level )
      {
          return M_filter_buf.setLevel( level );
      }
 
};
 
 
class gzifilterstream
    : public std::istream {
private:
    gzfilterstreambuf M_filter_buf;
 
    gzifilterstream( const gzifilterstream & ) = delete;
    gzifilterstream & operator=( const gzifilterstream & ) = delete;
 
public:
    explicit
    gzifilterstream( std::streambuf & src,
                     int level = gzfilterstreambuf::DEFAULT_COMPRESSION,
                     std::size_t buf_size = 8192 );
 
    explicit
    gzifilterstream( std::istream & src,
                     int level = gzfilterstreambuf::DEFAULT_COMPRESSION,
                     std::size_t buf_size = 8192 );
 
    bool setLevel( const int level )
      {
          return M_filter_buf.setLevel( level );
      }
 
};
 
 
class gzofilterstream
    : public std::ostream {
private:
    gzfilterstreambuf M_filter_buf;
 
    gzofilterstream( const gzofilterstream & ) = delete;
    gzofilterstream & operator=( const gzofilterstream & ) = delete;
public:
 
    explicit
    gzofilterstream( std::streambuf & dest,
                     int level = gzfilterstreambuf::DEFAULT_COMPRESSION,
                     std::size_t buf_size = 8192 );
 
    explicit
    gzofilterstream( std::ostream & dest,
                     int level = gzfilterstreambuf::DEFAULT_COMPRESSION,
                     std::size_t buf_size = 8192 );
 
    bool setLevel( const int level )
      {
          return M_filter_buf.setLevel( level );
      }
 
};
 
} // end namespace
 
#endif