gzstream.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                         (C) SuSE Linux Products GmbH |
\----------------------------------------------------------------------/
 
  File:       GzStream.h
 
  Author:     Michael Andres <ma@suse.de>
  Maintainer: Michael Andres <ma@suse.de>
 
  Purpose: Streams reading and writing gzip files.
 
/-*/
#ifndef ZYPP_CORE_BASE_GZSTREAM_H
#define ZYPP_CORE_BASE_GZSTREAM_H
 
#include <iosfwd>
#include <streambuf>
#include <vector>
#include <zlib.h>
 
#include <zypp-core/base/SimpleStreambuf>
#include <zypp-core/base/fXstream>
 
namespace zypp
{ 
 
  namespace gzstream_detail
  { 
 
    //
    //  CLASS NAME : ZlibError
    struct ZlibError
    {
      int _zError;
 
      int _errno;
 
      ZlibError()
      : _zError( 0 ), _errno( 0 )
      {}
 
      std::string
      strerror() const;
    };
 
    inline std::ostream & operator<<( std::ostream & str, const ZlibError & obj )
    { return str << obj.strerror(); }
 
 
    //
    //  CLASS NAME : gzstreambufimpl
    class gzstreambufimpl {
    public:
 
      using error_type = ZlibError;
 
      ~gzstreambufimpl()
      { closeImpl(); }
 
      bool
      isOpen   () const
      { return _file; }
 
      bool
      canRead  () const
      { return( _mode == std::ios_base::in ); }
 
      bool
      canWrite () const
      { return( _mode == std::ios_base::out ); }
 
      bool
      canSeek  ( std::ios_base::seekdir way_r ) const
      { return ( way_r == std::ios_base::beg || way_r == std::ios_base::cur ); }
 
    protected:
      bool openImpl( const char * name_r, std::ios_base::openmode mode_r );
      bool closeImpl ();
 
      off_t compressed_tell() const;
 
    public:
      error_type
      error() const
      { return _error; }
 
      std::streamsize readData ( char * buffer_r, std::streamsize maxcount_r  );
      bool writeData( const char * buffer_r, std::streamsize count_r );
      off_t seekTo( off_t off_r, std::ios_base::seekdir way_r, std::ios_base::openmode omode_r );
      off_t tell() const;
 
    private:
 
      void
      setZError() const
      { gzerror( _file, &_error._zError ); }
 
      int                        _fd = -1;
 
      gzFile                   _file = nullptr;
 
      std::ios_base::openmode  _mode = std::ios_base::openmode(0);
 
      mutable ZlibError        _error;
 
    };
    using fgzstreambuf = detail::SimpleStreamBuf<gzstreambufimpl>;
  } // namespace gzstream_detail
 
  typedef detail::fXstream<std::istream,gzstream_detail::fgzstreambuf> ifgzstream;
 
  typedef detail::fXstream<std::ostream,gzstream_detail::fgzstreambuf> ofgzstream;
 
} // namespace zypp
 
#endif // ZYPP_CORE_BASE_GZSTREAM_H