zipfstream.h

/*  zipfstream.h - zip iostream wrapper
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_zipfstream_h
#define OW32_zipfstream_h

#include <iostream>
#include <zlib.h>
#include <OW32/OW32Libs.h>

namespace OW32
{

using std::streambuf;
using std::ostream;
using std::istream;
using std::streamsize;
using std::ios_base;

class OW32_LIB_EXPORT zipfilebuf : public streambuf
{
public:
    zipfilebuf();
    zipfilebuf(const char* fname, 
        ios_base::openmode mode = ios_base::out | ios_base::trunc);
    ~zipfilebuf();
    bool open(const char* fname,
        ios_base::openmode mode = ios_base::out | ios_base::trunc);

protected:
    virtual int sync();
    virtual int_type underflow();
    virtual int_type overflow(int_type c);// = char_traits<char>::eof());

private:
    // TODO: find optimal chunk
    enum { CHUNK = 2048 };

    int m_flags;
    FILE* m_fp;
    z_stream m_flateStream;
    char m_in_buf[CHUNK]; // oh dear: dyn alloc?
    char m_storage[CHUNK];
    
    void Init();
};

class OW32_LIB_EXPORT ofzipstream : public ostream
    {   // output stream associated with a character array
public:
    ofzipstream()
        : ostream(&_Mysb), _Mysb()
        {   // construct with empty character array
        }

    ofzipstream(const char *fname, 
        ios_base::openmode mode = ios_base::out | ios_base::trunc)
        : ostream(&_Mysb), _Mysb(fname, mode)
    {   // construct with file name
    }

//  _CRTIMP2 virtual ~ofzipstream();    // destroy the object

    zipfilebuf *rdbuf() const
        {   // return pointer to character array buffer
        return ((zipfilebuf *)&_Mysb);
        }

private:
    ofzipstream(const ofzipstream& );
    ofzipstream& operator=(const ofzipstream& );

    zipfilebuf _Mysb;   // the character array buffer
    };

class OW32_LIB_EXPORT ifzipstream : public istream
    {   // output stream associated with a character array
public:
    ifzipstream()
        : istream(&_Mysb), _Mysb()
        {   // construct with empty character array
        }

    ifzipstream(const char *fname, 
        ios_base::openmode mode = ios_base::in)
        : istream(&_Mysb), _Mysb(fname, mode)
    {   // construct with file name
    }

    void open(const char *fname, 
        ios_base::openmode mode = ios_base::in)
    {
        if (!_Mysb.open(fname, mode))
            setstate(ios_base::failbit);
    }
//  _CRTIMP2 virtual ~ofzipstream();    // destroy the object

    zipfilebuf *rdbuf() const
        {   // return pointer to character array buffer
        return ((zipfilebuf *)&_Mysb);
        }

private:
    ifzipstream(const ifzipstream& );
    ifzipstream& operator=(const ifzipstream& );
    zipfilebuf _Mysb;   // the character array buffer
    };

} // namespace std

#endif // OW32_zipfstream_h

---