---

zipiostream.h

Go to the documentation of this file.

#include <iostream>
#include <zlib.h>

#ifndef __ZIPIOSTREAM_H__
#define __ZIPIOSTREAM_H__


#define zapeof(c) ((c)&0377)


class zipstreambuf : public streambuf
{
public:
  static const int openprot;
private:
  char opened;
  int mode;
  gzFile file;
public:
  zipstreambuf() { opened = 0; }
  int is_open() const { return opened; }

  
  zipstreambuf* open(const char * name, int om) {
    if (is_open())
      return (zipstreambuf*)0;

    mode = om;
    // no append nor read/write mode
    if ((mode & ios::ate) || (mode & ios::app)
        || ((mode & ios::in) && (mode & ios::out)))
      return (zipstreambuf*)0;

    char fmode[10];
    char * fmodeptr = fmode;
    if (mode & ios::in)
      {
        *fmodeptr++ = 'r';
      }
    else if (mode & ios::out)
      *fmodeptr++ = 'w';
    *fmodeptr++ = 'b';
    *fmodeptr = '\0';
        
    file = gzopen(name,fmode);
    if (file == NULL)
      return (zipstreambuf*)0;
  
    opened = 1;
    return this;
  }

  
  zipstreambuf* close() {
    if (opened)
      {
        sync();
        opened = 0;
        if (gzclose(file) == Z_OK)
          return this;
      }
    return (zipstreambuf*)0;
  }
    
  
  ~zipstreambuf() { close(); }

  virtual int     overflow(int c=EOF) {
        
    if (!(mode&ios::out) || !opened || allocate()==EOF) return EOF;
    if (gptr() && egptr() > gptr())
      return EOF;

    setg(0,0,0);

    // make sure there is a put area
    if (!pptr()) setp(base(),base());

    int w = pptr() -pbase();

    if (c != EOF)
      {
        *pptr() = c;
        ++w;
      }

    if (gzwrite(file,pbase(),w))
      {
        setp(base(),ebuf()-1);
        return zapeof(c);
      }

    setp(0,0);
    return EOF;
  }

    
  virtual int     underflow() {
    if (gptr() && gptr() < egptr()) return zapeof(*gptr());

    if (!(mode&ios::in) || !opened || allocate()==EOF) return EOF;

    int count = gzread(file,base(),blen());
    if (count < 1)
      {
        setg(0,0,0);
        return EOF;
      }
    setg(base(),base(),base()+count);
    return zapeof(*base());
  }


    
  virtual int     sync() {
    if (gptr() && egptr() > gptr())
      return EOF;
    if (pptr() && pptr() > pbase())
      return overflow(EOF);

    return 0;
  }

  /* NYI
     virtual streambuf*
     setbuf(char*  p, int len) ;
  */
};



class zipstreambase : virtual public ios
{
  zipstreambuf buf;
public:
  zipstreambase() {init(&buf);}
  zipstreambase(const char* name, int mode) {
    init(&buf);
    open(name,mode);
  }
  ~zipstreambase() {
    if(buf.is_open())
      buf.close();
  }

  void open(const char* name, int mode){
    if (!buf.open(name,mode))
      clear(rdstate() & ios::badbit);
  }

  void close(){
    if (buf.is_open())
      if (!buf.close())
        clear(rdstate() & ios::badbit);
  }

  inline operator bool()  const {  return  buf.is_open(); }
  inline bool operator!() const {  return !buf.is_open(); }  

  // NYI  void setbuf(char*  p, int l);
  zipstreambuf* rdbuf() { return &buf; }
};



class izipstream : public zipstreambase, public istream
{
public:
  izipstream() {}
  izipstream(const char* name,
             int mode=ios::in)
    : zipstreambase(name,mode) {}

  zipstreambuf* rdbuf() {return zipstreambase::rdbuf(); }
  void open(const char* name)
    {zipstreambase::open(name,ios::in);}
};



class ozipstream : public zipstreambase, public ostream
{
public:
  ozipstream() {}
  ozipstream(const char* name,
             int mode=ios::out)
    : zipstreambase(name,mode) {}

  zipstreambuf* rdbuf() {return zipstreambase::rdbuf(); }
  void open(const char* name)
    {zipstreambase::open(name,ios::out);}
};


#endif /* __ZIPIOSTREAM_H__ */

---