GZFile.hpp

Go to the documentation of this file.

 
#ifndef H_POTTU_GZFILE
#define H_POTTU_GZFILE
 
#include <zlib.h>
 
#include <string>
#include <stdexcept>
#include <cstring>
#include <cstdint>
 
 
namespace pottu {
 
    
    class GZFile {
    public:
 
    GZFile() = default;
    GZFile( const GZFile &o ) = delete;
 
    GZFile( GZFile &&rhs ) {
        swap( *this, rhs );
    }
    
    friend void swap( GZFile &lhs, GZFile &rhs ) noexcept {
        using std::swap;
        swap( lhs._f, rhs._f );
    }
 
    GZFile &operator=(GZFile rhs) noexcept {
        swap( *this, rhs );
        return *this;
    }
    
    
    GZFile( const std::string &filename, const std::string &openmode )
        {
        _f = gzopen( filename.c_str(), openmode.c_str() );
 
        if( !_f ) {
            int errnum;
            std::string errormsg = gzerror( _f, &errnum );
            throw std::runtime_error( errormsg );
        }
        
        }
 
    ~GZFile()
        {
        if( _f )
            gzclose( _f );
        }
 
    void open( const std::string &filename, const std::string &openmode ) {
        if( _f )
        return;
        errno = 0;
        _f = gzopen( filename.c_str(), openmode.c_str() );
        if( !_f )
        throw std::runtime_error( std::strerror(errno) );
    }
 
    void close() {
        if( _f ) {
        gzclose( _f );
        _f = nullptr;
        }
    }
 
    int read( char *buf, unsigned int size ) {
        if( !_f )
        throw std::runtime_error( "Cannot read. File is not open." );
        int ret = gzread( _f, (void *)buf, size );
        if( ret == -1 ) {
        int errnum;
        throw std::runtime_error( gzerror( _f, &errnum ) );
        }
        return ret;
    }
 
 
    void seek( size_t position ) {
        if( !_f )
        throw std::runtime_error( "Cannot seek. File is not open." );
        z_off_t ret = gzseek( _f, position, SEEK_SET );
        if( ret < 0 )
        throw std::runtime_error( "gzseek() failed." );
    }
 
    
    bool isOpen() const noexcept { return _f != nullptr; }
 
    bool isZipped() const noexcept { return _f ? gzdirect(_f) != 1 : false; }
 
 
    bool isEof() const noexcept { return _f ? gzeof(_f) : false; }
 
    uint64_t getPosition() const noexcept { return _f ? gzoffset(_f) : 0; }
    
    gzFile _f{nullptr};
    };
 
 
}
 
    
#endif