zstream.h

Go to the documentation of this file.

#ifndef _utl_zstream_h_
#define _utl_zstream_h_

#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/bzip2.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/shared_ptr.hpp>

/*
  \author Darko Veberic
  \version $Id: zstream.h 521 2017-01-21 14:53:20Z darko $
*/


namespace utl {

  enum class zip_type {
    none = 0,
    gzip = 1,
    bzip2 = 2,
    xzip = 3,
    automatic = 16,
  };


  namespace detail {

    template<
      class filtering_stream,
      class gzip_compressor,
      class bzip2_compressor
    >
    struct zfilter : public filtering_stream {
      zfilter() : filtering_stream() { }

      template<class stream>
      zfilter(stream& strm, const zip_type ztype)
      { push(strm, ztype); }

      ~zfilter() { this->reset(); }

      template<class stream>
      void
      push(stream& strm, const zip_type ztype)
      {
        this->reset();
        if (static_cast<int>(ztype) >= 4)
          throw std::invalid_argument("only zip options allowed for zfilter");
        switch (static_cast<int>(ztype) & 3) {
        case static_cast<int>(zip_type::none):
          break;
        case static_cast<int>(zip_type::gzip):
          filtering_stream::push(gzip_compressor());
          break;
        case static_cast<int>(zip_type::bzip2):
          filtering_stream::push(bzip2_compressor());
          break;
        case static_cast<int>(zip_type::xzip):
          throw std::invalid_argument("xzip not implemented yet");
        }
        filtering_stream::push(strm);
      }
    };


    typedef zfilter<
      boost::iostreams::filtering_istream,
      boost::iostreams::gzip_decompressor,
      boost::iostreams::bzip2_decompressor
    > zifilter;


    typedef zfilter<
      boost::iostreams::filtering_ostream,
      boost::iostreams::gzip_compressor,
      boost::iostreams::bzip2_compressor
    > zofilter;

  }


  //


  class zstream_source {
  private:
    struct impl {
      template<class stream>
      impl(stream& strm, const zip_type ztype) { _filter.push(strm, ztype); }
      detail::zifilter _filter;
    };

  public:
    typedef char char_type;
    struct category :
      boost::iostreams::input,
      boost::iostreams::device_tag,
      boost::iostreams::closable_tag
    { };

    zstream_source() { }

    template<class istream>
    zstream_source(istream& is, const zip_type ztype = zip_type::none)
    { attach(is, ztype); }

    template<class istream>
    void attach(istream& is, const zip_type ztype = zip_type::none)
    { _impl.reset(new impl(is, ztype)); }

    void close() { _impl->_filter.reset(); }

    std::streamsize read(char* const s, const std::streamsize n)
    { return boost::iostreams::read(_impl->_filter, s, n); }

    bool is_complete() const { return _impl && _impl->_filter.is_complete(); }

  private:
    boost::shared_ptr<impl> _impl;
  };


  typedef boost::iostreams::stream<zstream_source> zistream;


  //


  class zstream_sink {
  private:
    struct impl {
      template<class stream>
      impl(stream& strm, const zip_type ztype) { _filter.push(strm, ztype); }
      detail::zofilter _filter;
    };

  public:
    typedef char char_type;
    struct category :
      boost::iostreams::output,
      boost::iostreams::device_tag,
      boost::iostreams::closable_tag,
      boost::iostreams::flushable_tag
    { };

    zstream_sink() { }

    template<class ostream>
    zstream_sink(ostream& os, const zip_type ztype = zip_type::none)
    { attach(os, ztype); }

    template<class ostream>
    void attach(ostream& os, const zip_type ztype = zip_type::none)
    { _impl.reset(new impl(os, ztype)); }

    void close() { _impl.reset(); }

    std::streamsize write(const char* const s, const std::streamsize n)
    { return boost::iostreams::write(_impl->_filter, s, n); }

    bool flush() { return bool(_impl->_filter.flush()); }

    bool is_complete() const { return _impl->_filter.is_complete(); }

  private:
    boost::shared_ptr<impl> _impl;
  };


  typedef boost::iostreams::stream<zstream_sink> zostream;

}


#endif