src/stream/ZStrim.h

/*  @(#) $Id: ZStrim.h,v 1.21 2007/01/10 01:28:51 agreen Exp $ */

/* ------------------------------------------------------------
Copyright (c) 2003 Andrew Green and Learning in Motion, Inc.
http://www.zoolib.org

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
------------------------------------------------------------ */

#ifndef __ZStrim__
#define __ZStrim__ 1
#include "zconfig.h"

#include "ZUnicode.h"
#include <stdexcept> // For range_error

class ZStrimW;

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimR

class ZStrimR
        {
protected:      //@{
        ZStrimR() {}
        ~ZStrimR() {}
        ZStrimR(const ZStrimR&) {}
        ZStrimR& operator=(const ZStrimR&) { return *this; }


public:
        class ExEndOfStrim;
        static void sThrowEndOfStrim();
        //@{
        bool ReadCP(UTF32& oCP) const;
        UTF32 ReadCP() const;
        
        //@{
        string32 ReadUTF32(size_t iCountCP) const;
        string16 ReadUTF16(size_t iCountCP) const;
        string8 ReadUTF8(size_t iCountCP) const;

        //@{
        void Read(UTF32* iDest, size_t iCount, size_t* oCount) const;
        void Read(UTF16* iDest, size_t iCountCU, size_t* oCountCU) const;
        void Read(UTF8* iDest, size_t iCountCU, size_t* oCountCU) const;

        //@{
        void Read(UTF16* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP) const;

        void Read(UTF8* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP) const;

        //@{
        void CopyAllTo(const ZStrimW& iStrimW) const;
        void CopyAllTo(const ZStrimW& iStrimW, size_t* oCountCPRead, size_t* oCountCPWritten) const;

        void CopyTo(const ZStrimW& iStrimW, size_t iCountCP) const;

        void CopyTo(const ZStrimW& iStrimW,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten) const;

        //@{
        void Skip(size_t iCountCP) const;
        void Skip(size_t iCountCP, size_t* oCountCPSkipped) const;
        void SkipAll() const;
        void SkipAll(size_t* oCountCPSkipped) const;

        //@{
        virtual void Imp_ReadUTF32(UTF32* iDest, size_t iCount, size_t* oCount) = 0;

        //@{
        virtual void Imp_ReadUTF16(UTF16* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

        virtual void Imp_ReadUTF8(UTF8* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

        virtual void Imp_CopyToDispatch(const ZStrimW& iStrimW,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_CopyTo(const ZStrimW& iStrimW,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_Skip(size_t iCountCP, size_t* oCountCPSkipped);
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimR::ExEndOfStrim

class ZStrimR::ExEndOfStrim : public std::range_error
        {
public:
        ExEndOfStrim();
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimU

class ZStrimU : public ZStrimR
        {
public:
        void Unread() const;

        virtual void Imp_Unread() = 0;
        };

inline void ZStrimU::Unread() const
        { const_cast<ZStrimU*>(this)->Imp_Unread(); }

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimW

class ZStrimW
        {
protected:      //@{
        ZStrimW() {}
        ~ZStrimW() {}
        ZStrimW(const ZStrimW&) {}
        ZStrimW& operator=(const ZStrimW&) { return *this; }


public:
        class ExEndOfStrim;
        static void sThrowEndOfStrim();
        //@{
        void WriteCP(UTF32 iCP) const;

        //@{
        void Write(const UTF32* iString) const;
        void Write(const UTF16* iString) const;
        void Write(const UTF8* iString) const;

        //@{
        void Write(const string32& iString) const;
        void Write(const string16& iString) const;
        void Write(const string8& iString) const;

        //@{
        void Write(const UTF32* iSource, size_t iCountCU) const;
        void Write(const UTF16* iSource, size_t iCountCU) const;
        void Write(const UTF8* iSource, size_t iCountCU) const;

        //@{
        void Write(const UTF32* iSource, size_t iCountCU, size_t* oCountCU) const;
        void Write(const UTF16* iSource, size_t iCountCU, size_t* oCountCU) const;
        void Write(const UTF8* iSource, size_t iCountCU, size_t* oCountCU) const;

        //@{
        void Write(const UTF32* iSource,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP) const;

        void Write(const UTF16* iSource,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP) const;

        void Write(const UTF8* iSource,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP) const;

        //@{
        size_t Writef(const UTF8* iString, ...) const;

        //@{
        void CopyAllFrom(const ZStrimR& iStrimR) const;
        void CopyAllFrom(const ZStrimR& iStrimR, size_t* oCountCPRead, size_t* oCountCPWritten) const;

        void CopyFrom(const ZStrimR& iStrimR, size_t iCountCP) const;

        void CopyFrom(const ZStrimR& iStrimR,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten) const;

        //@{
        void Flush() const;

        //@{
        virtual void Imp_WriteUTF32(const UTF32* iSource, size_t iCountCU, size_t* oCountCU) = 0;
        virtual void Imp_WriteUTF16(const UTF16* iSource, size_t iCountCU, size_t* oCountCU) = 0;
        virtual void Imp_WriteUTF8(const UTF8* iSource, size_t iCountCU, size_t* oCountCU) = 0;

        //@{
        virtual void Imp_CopyFromDispatch(const ZStrimR& iStrimR,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_CopyFrom(const ZStrimR& iStrimR,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_Flush();
        };

inline const ZStrimW& operator<<(const ZStrimW& s, const string32& iString)
        {
        s.Write(iString);
        return s;
        }

inline const ZStrimW& operator<<(const ZStrimW& s, const UTF32* iString)
        {
        s.Write(iString);
        return s;
        }

inline const ZStrimW& operator<<(const ZStrimW& s, const string16& iString)
        {
        s.Write(iString);
        return s;
        }

inline const ZStrimW& operator<<(const ZStrimW& s, const UTF16* iString)
        {
        s.Write(iString);
        return s;
        }

inline const ZStrimW& operator<<(const ZStrimW& s, const string8& iString)
        {
        s.Write(iString);
        return s;
        }

inline const ZStrimW& operator<<(const ZStrimW& s, const UTF8* iString)
        {
        s.Write(iString);
        return s;
        }

inline const ZStrimW& operator<<(const ZStrimW& s, const ZStrimR& r)
        {
        s.CopyAllFrom(r);
        return s;
        }

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimW::ExEndOfStrim

class ZStrimW::ExEndOfStrim : public std::range_error
        {
public:
        ExEndOfStrim();
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimW_NativeUTF32

class ZStrimW_NativeUTF32 : public ZStrimW
        {
public:
        virtual void Imp_WriteUTF32(const UTF32* iSource, size_t iCountCU, size_t* oCountCU) = 0;
        virtual void Imp_WriteUTF16(const UTF16* iSource, size_t iCountCU, size_t* oCountCU);
        virtual void Imp_WriteUTF8(const UTF8* iSource, size_t iCountCU, size_t* oCountCU);
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimW_NativeUTF16

class ZStrimW_NativeUTF16 : public ZStrimW
        {
public:
        virtual void Imp_WriteUTF32(const UTF32* iSource, size_t iCountCU, size_t* oCountCU);
        virtual void Imp_WriteUTF16(const UTF16* iSource, size_t iCountCU, size_t* oCountCU) = 0;
        virtual void Imp_WriteUTF8(const UTF8* iSource, size_t iCountCU, size_t* oCountCU);
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimW_NativeUTF8

class ZStrimW_NativeUTF8 : public ZStrimW
        {
public:
        virtual void Imp_WriteUTF32(const UTF32* iSource, size_t iCountCU, size_t* oCountCU);
        virtual void Imp_WriteUTF16(const UTF16* iSource, size_t iCountCU, size_t* oCountCU);
        virtual void Imp_WriteUTF8(const UTF8* iSource, size_t iCountCU, size_t* oCountCU) = 0;
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimR_Null


class ZStrimR_Null : public ZStrimR
        {
public:
        virtual void Imp_ReadUTF32(UTF32* iDest, size_t iCount, size_t* oCount);

        virtual void Imp_ReadUTF16(UTF16* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

        virtual void Imp_ReadUTF8(UTF8* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

        virtual void Imp_CopyToDispatch(const ZStrimW& iStrimW,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_CopyTo(const ZStrimW& iStrimW,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_Skip(size_t iCountCP, size_t* oCountCPSkipped);
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimW_Null


class ZStrimW_Null : public ZStrimW
        {
public:
        virtual void Imp_WriteUTF32(const UTF32* iSource, size_t iCountCU, size_t* oCountCU);
        virtual void Imp_WriteUTF16(const UTF16* iSource, size_t iCountCU, size_t* oCountCU);
        virtual void Imp_WriteUTF8(const UTF8* iSource, size_t iCountCU, size_t* oCountCU);

        virtual void Imp_CopyFromDispatch(const ZStrimR& iStrimR,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_CopyFrom(const ZStrimR& iStrimR,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);
        };

typedef ZStrimW_Null ZStrimW_Sink; // Old name.

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimU_Unreader


class ZStrimU_Unreader : public ZStrimU
        {
public:
        ZStrimU_Unreader(const ZStrimR& iStrimSource);

// From ZStrimR via ZStrimU 
        virtual void Imp_ReadUTF32(UTF32* iDest, size_t iCount, size_t* oCount);

        virtual void Imp_ReadUTF16(UTF16* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

        virtual void Imp_ReadUTF8(UTF8* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

// From ZStrimU
        virtual void Imp_Unread();

private:
        const ZStrimR& fStrimSource;
        enum { eStateFresh, eStateNormal, eStateUnread, eStateHitEnd } fState;
        UTF32 fCP;
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimU_String8


class ZStrimU_String8 : public ZStrimU
        {
public:
        ZStrimU_String8(const string8& iString);
        ~ZStrimU_String8();

// From ZStrimR via ZStrimU
        virtual void Imp_ReadUTF32(UTF32* iDest, size_t iCount, size_t* oCount);

        virtual void Imp_ReadUTF16(UTF16* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

        virtual void Imp_ReadUTF8(UTF8* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

// From ZStrimU
        virtual void Imp_Unread();

private:
        string8 fString;
        size_t fPosition;
        };

typedef ZStrimU_String8 ZStrimU_String;

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimU_String


class ZStrimU_String32 : public ZStrimU
        {
public:
        ZStrimU_String32(const string32& iString);
        ~ZStrimU_String32();

// From ZStrimR via ZStrimU
        virtual void Imp_ReadUTF32(UTF32* iDest, size_t iCount, size_t* oCount);

        virtual void Imp_ReadUTF16(UTF16* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

        virtual void Imp_ReadUTF8(UTF8* iDest,
                size_t iCountCU, size_t* oCountCU, size_t iCountCP, size_t* oCountCP);

// From ZStrimU
        virtual void Imp_Unread();

private:
        string32 fString;
        size_t fPosition;
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimW_String


class ZStrimW_String : public ZStrimW_NativeUTF8
        {
public:
        ZStrimW_String(string8& iString);
        ~ZStrimW_String();

        virtual void Imp_WriteUTF8(const UTF8* iSource, size_t iCountCU, size_t* oCountCU);

private:
        string8& fString;
        };

// =================================================================================================
#pragma mark -
#pragma mark * ZStrimW_Indirect

class ZStrimW_Indirect : public ZStrimW
        {
public:
        ZStrimW_Indirect();
        ZStrimW_Indirect(const ZStrimW& iStrimW);
        ~ZStrimW_Indirect();

// From ZStrimW
        virtual void Imp_WriteUTF32(const UTF32* iSource, size_t iCountCU, size_t* oCountCU);
        virtual void Imp_WriteUTF16(const UTF16* iSource, size_t iCountCU, size_t* oCountCU);
        virtual void Imp_WriteUTF8(const UTF8* iSource, size_t iCountCU, size_t* oCountCU);

        virtual void Imp_CopyFromDispatch(const ZStrimR& iStrimR,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_CopyFrom(const ZStrimR& iStrimR,
                size_t iCountCP, size_t* oCountCPRead, size_t* oCountCPWritten);

        virtual void Imp_Flush();

// Our protocol
        void SetSink(const ZStrimW& iStrimW);
        void SetSink(const ZStrimW* iStrimW);

private:
        const ZStrimW* fSink;
        };

#endif // __ZStrim__

---