zipstrstream.h

/*  zipstrstream.cpp - 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_zipstrstream_h
#define OW32_zipstrstream_h

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

namespace OW32
{

// Unfortunately VC++ can't cope without these using declarations because 
// if you try deriving from a class with an explicit namespace then you
// can't initialise it in the constructor like normal - just a bug i guess
using std::streambuf;
using std::ostream;
using std::istream;
using std::streamsize;

#ifdef _MSC_VER
#pragma warning(disable: 4251)
#endif

class OW32_LIB_EXPORT zipstrstreambuf : public streambuf
{
public:
    void freeze(bool frz = true) const;
    char* str() { return (char*)m_storage.str(); }
    streamsize pcount() const { return (streamsize)m_flateStream.total_out; }

    zipstrstreambuf(const char* in, int length);
    zipstrstreambuf();
    ~zipstrstreambuf();

protected:
    virtual int sync();
    virtual streamsize xsgetn(char *s, streamsize n);
    virtual int_type underflow();
    virtual streamsize xsputn(const char *s, streamsize n);
    virtual int_type overflow(int_type c);// = char_traits<char>::eof());

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

    int m_flags;
    z_stream m_flateStream;
    OW32::auto_byte_buf m_storage;

    void expandFlateStream();
    void Init();
};
#ifdef _MSC_VER
#pragma warning(default: 4251)
#endif

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

    ozipstrstream(char *, streamsize,
        ios_base::openmode =
            ios_base::out); // construct with static array

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

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

    void freeze(bool _Freezeit = true)
        {   // freeze or unfreeze writing
        _Mysb.freeze(_Freezeit);
        }

    char *str()
        {   // freeze and return pointer to character array 
        flush();
        return (_Mysb.str());
        }

    streamsize pcount() const
        {   // return size of writable character array
        return (_Mysb.pcount());
        }

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

    zipstrstreambuf _Mysb;  // the character array buffer
    };

class OW32_LIB_EXPORT izipstrstream
    : public istream
    {   // input stream associated with a character array
public:

    /*explicit istrstream(const char *_Ptr)
        : istream(&_Mysb), _Mysb(_Ptr, 0)
        {   // construct with NTBS
        }*/

    izipstrstream(const char *_Ptr, streamsize _Count)
        : istream(&_Mysb), _Mysb(_Ptr, _Count)
        {   // construct with [_Ptr, _Ptr + _Count)
        }

/*  explicit istrstream(char *_Ptr)
        : istream(&_Mysb), _Mysb((const char *)_Ptr, 0)
        {   // construct with NTBS
        }*/

    izipstrstream(char *_Ptr, int _Count)
        : istream(&_Mysb), _Mysb((const char *)_Ptr, _Count)
        {   // construct with [_Ptr, _Ptr + _Count)
        }

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

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

    char *str()
        {   // freeze and return pointer to character array
        return (_Mysb.str());
        }

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

    zipstrstreambuf _Mysb;  // the string buffer
    };

};

#endif // OW32_zipstrstream_h

---