zfstream.h

Go to the documentation of this file.

#ifndef _utl_zfstream_h_
#define _utl_zfstream_h_

#include <utl/zstream.h>
#include <boost/iostreams/positioning.hpp>
#include <boost/iostreams/optimal_buffer_size.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/filesystem.hpp>
#include <fstream>


namespace utl {

  namespace detail {

    inline
    bool
    is_automatic(const zip_type ztype)
    {
      return static_cast<int>(ztype) & static_cast<int>(zip_type::automatic);
    }


    inline
    zip_type
    deduce_zip_type(const std::string& filename, const zip_type ztype)
    {
      if (!is_automatic(ztype))
        return ztype;
      const auto ext = boost::filesystem::extension(filename);
      if (ext == ".bz2")
        return zip_type::bzip2;
      if (ext == ".gz")
        return zip_type::gzip;
      if (ext == ".xz")
        return zip_type::xzip;
      return zip_type::none;
    }

  }


  class zfstream_source {
  private:
    struct impl {
      void
      init()
      {
        ++_n_open_calls;
        _stream.close();
        _stream.open(_filename.c_str(), _openmode);
        _position = 0;
        _filter.push(_stream, _zip_type);
      }

      unsigned int _n_open_calls = 0;
      std::string _filename;
      zip_type _zip_type;
      std::ios_base::openmode _openmode;
      std::ifstream _stream;
      std::size_t _position;
      detail::zifilter _filter;
    };

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

    zfstream_source() { }

    zfstream_source(const std::string& filename, const zip_type ztype)
    { open(filename, ztype); }

    zfstream_source(const std::string& filename,
                    const std::ios_base::openmode openmode = std::ios_base::in,
                    const zip_type ztype = zip_type::automatic)
    { open(filename, openmode, ztype); }

    void open(const std::string& filename, const zip_type ztype)
    { open(filename, std::ios_base::in, ztype); }

    void
    open(const std::string& filename,
         const std::ios_base::openmode openmode = std::ios_base::in,
         const zip_type ztype = zip_type::automatic)
    {
      _impl.reset(new impl);
      _impl->_filename = filename;
      _impl->_zip_type = detail::deduce_zip_type(filename, ztype);
      _impl->_openmode = (_impl->_zip_type == zip_type::none ? openmode : std::ios_base::binary);
      _impl->init();
    }

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

    std::streamsize
    read(char* const s, const std::streamsize n)
    {
      const auto size = boost::iostreams::read(_impl->_filter, s, n);
      if (size > 0)
        _impl->_position += size;
      return size;
    }

    boost::iostreams::stream_offset
    seek(const boost::iostreams::stream_offset off, const std::ios_base::seekdir way)
    {
      const auto old = _impl->_position;
      // determine new value of fPosition
      std::size_t next;
      if (way == std::ios_base::beg) {
        if (off < 0)
          throw std::ios_base::failure("bad seek offset");
        next = off;
      } else if (way == std::ios_base::cur)
        next = old + off;
      else
        throw std::ios_base::failure("bad seek direction");

      if (next == old)
        return _impl->_position;

      std::size_t skip;

      if (next > old)
        skip = next - old;
      else {
        _impl->_filter.reset();
        _impl->_stream.close();
        _impl->init();
        skip = next;
      }

      const std::streamsize chunk = boost::iostreams::optimal_buffer_size(_impl->_filter);
      char buff[chunk];

      for (std::size_t i = 0, n = skip/chunk; i < n; ++i)
        if (read(buff, chunk) != chunk)
          return -1; // EOF

      const std::streamsize rest = skip % chunk;
      if (rest && read(buff, rest) != rest)
        return -1; // EOF

      if (_impl->_position != next)
        throw std::ios_base::failure("bad seek result");

      return _impl->_position;
    }

    std::size_t tellg() const { return _impl ? _impl->_position : 0; }

    int get_n_open_calls() const { return _impl ? _impl->_n_open_calls : -1; }

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

    zip_type get_zip_type() const { return _impl->_zip_type; }

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


  /*
    \class zifstream zifstream.h "utl/zfstream.h"

    NB: the interface is the same as the usual std::istream type
    in order for the class to be used as a drop-in replacement for
    std::ifstream.

    Usage:
    \code
    {
      zifstream ifs("foo.bz2");
      string h;
      ifs >> h;
      int i;
      ifs >> i;
    }
    \endcode

    \author Darko Veberic
    \date 12 May 2010
    \date 20 Oct 2011 redesign
  */

  class zifstream : public boost::iostreams::stream<zfstream_source> {
  private:
    typedef boost::iostreams::stream<zfstream_source> base;

  public:
    zifstream() : base(zfstream_source()) { }

    zifstream(const std::string& filename, const zip_type ztype)
      : base(zfstream_source(filename, ztype)) { }

    zifstream(const std::string& filename,
              const std::ios_base::openmode om = std::ios_base::in,
              const zip_type ztype = zip_type::automatic)
      : base(zfstream_source(filename, om, ztype)) { }

    void open(const std::string& filename, const zip_type ztype)
    { (**this).open(filename, std::ios_base::in, ztype); }

    void open(const std::string& filename,
              const std::ios_base::openmode om = std::ios_base::in,
              const zip_type ztype = zip_type::automatic)
    { (**this).open(filename, om, ztype); }

    int get_n_open_calls() { return this->is_open() ? (**this).get_n_open_calls() : -1; }

    bool is_complete() { return this->is_open() && (**this).is_complete(); }

    zip_type get_zip_type() { return (**this).get_zip_type(); }
  };


  //


  class zfstream_sink {
  private:
    struct impl {
      impl(const std::string& filename,
           const std::ios_base::openmode om,
           const zip_type ztype)
        : _stream(filename.c_str(), om), _filter(_stream, ztype), _zip_type(ztype) { }
      std::ofstream _stream;
      detail::zofilter _filter;
      zip_type _zip_type;
    };

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

    zfstream_sink() { }

    zfstream_sink(const std::string& filename, const zip_type ztype)
    { open(filename, ztype); }

    zfstream_sink(const std::string& filename,
                  const std::ios_base::openmode om = std::ios_base::out,
                  const zip_type ztype = zip_type::automatic)
    { open(filename, om, ztype); }

    void open(const std::string& filename, const zip_type ztype)
    { open(filename, std::ios_base::out, ztype); }

    void
    open(const std::string& filename,
         const std::ios_base::openmode omode = std::ios_base::out,
         zip_type ztype = zip_type::automatic)
    {
      ztype = detail::deduce_zip_type(filename, ztype);
      const std::ios_base::openmode om =
        (ztype == zip_type::none ? omode : std::ios_base::binary);
      _impl.reset(new impl(filename, om, 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 && _impl->_filter.is_complete(); }

    zip_type get_zip_type() const { return _impl->_zip_type; }

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


  /*
    \class zofstream zfstream.h "utl/zfstream.h"

    NB: the interface is the same as the usual std::ostream type
    in order for the class to be used as a drop-in replacement for
    std::ofstream.

    Usage:
    \code
    {
      zofstream ofs("foo.bz2");
      ofs << "hallo " << 13 << endl;
    }
    \endcode

    \author Darko Veberic
    \date 12 May 2010
    \date 20 Oct 2011 redesign
  */

  class zofstream : public boost::iostreams::stream<zfstream_sink> {
  private:
    typedef boost::iostreams::stream<zfstream_sink> base;

  public:
    zofstream() : base(zfstream_sink()) { }

    zofstream(const std::string& filename, const zip_type ztype)
      : base(zfstream_sink(filename, ztype)) { }

    zofstream(const std::string& filename,
              const std::ios_base::openmode omode = std::ios_base::out,
              const zip_type ztype = zip_type::automatic)
      : base(zfstream_sink(filename, omode, ztype)) { }

    void open(const std::string& filename, const zip_type ztype)
    { (**this).open(filename, std::ios_base::out, ztype); }

    void open(const std::string& filename,
              const std::ios_base::openmode omode = std::ios_base::out,
              const zip_type ztype = zip_type::automatic)
    { (**this).open(filename, omode, ztype); }

    bool is_complete() { return this->is_open() && (**this).is_complete(); }

    zip_type get_zip_type() { return (**this).get_zip_type(); }
  };


}


#endif