FileUnZip unzip(filename);
StrIOStream unzipStream; //my simple String-based FIFO class
unzip.ReadFile(unzipStream, callback(this, &MyClass::OnZipData));
while (unzipStream.GetSize())
    ProcessChunk(&unzipStream);
...

bool MyClass::OnZipData(int op1, int op2)
{
    ProcessChunk(&unzipStream);
    return isShutdown; //usually false
}

void MyClass::ProcessChunk(Stream *stream)
{
    String data = stream->Get(static_cast<int>(stream->GetSize())); //get unzipped data
    ... //process the chunk of unzipped data
}

class StrIOStream : public Stream 
{
protected:
	virtual  void  _Put(int w)
	{
		data.Cat(w);
	}
	
	virtual  int   _Term()
	{
		return data.IsEmpty() ? -1 : data[0];
	}
	
	virtual  int   _Get()
	{
		if (data.IsEmpty())
		return -1;
		
		int w = data[0];
		data.Remove(0);
		return w;
	}
	
	virtual  void  _Put(const void *_data, dword size)
	{
		data.Cat((const char *) _data,size);
	}
	
	virtual  dword _Get(void *_data, dword size)
	{
		dword l = min(size,(dword)data.GetLength());
		memcpy(_data,~data,l);
		data.Remove(0,l);
		return l;
	}

public:
	virtual  void  Seek(int64 pos) {}
	virtual  int64 GetSize() const {return data.GetLength();}
	virtual  void  SetSize(int64 size)
	{
		if (size == data.GetLength())
			return;
		if (size > data.GetLength())
			data.Cat('?', static_cast<int>(size-data.GetLength()));
		else
			data.Trim(static_cast<int>(size));
	}
	virtual  bool  IsOpen() const {return true;}

protected:
	String         data;
	
public:
	void        Open(const String& _data) {data = _data;}
	void        Create() {}
	void        Reserve(int n) {data.Reserve(n);}

	String      GetResult() {return data;}
	operator    String()                     { return data; }
};