// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Classes defined in this file are used for Unicode compression and decompression.

// Their code is borrowed from Symbian, only with some changes such as the "Panic" function 

// is changed to exit the program. The Symbian coding standard will be kept in the code.

// 

//

#if !defined(__UNICODECOMPRESSION_H__)

#define __UNICODECOMPRESSION_H__

#include <stdio.h>

#include <pcstore/pcstoredef.h>

#include <pcstore/storereadstream.h>

#include <pcstore/storewritestream.h>

#include "pcstoreconst.h"

namespace PCStore

{

/**

@internalComponent

*/

class TUnicodeCompressionState

    {

    public:

    TUnicodeCompressionState();

    void Reset();

    static TInt StaticWindowIndex(TUint16 aCode);

    static TInt DynamicWindowOffsetIndex(TUint16 aCode);

    static TUint32 DynamicWindowBase(TInt aOffsetIndex);

    static TBool EncodeAsIs(TUint16 aCode);

    enum TPanic

        {

        EUnhandledByte,         // expander code fails to handle all possible byte codes

        ENotUnicode,            // expander can't handle Unicode values outside range 0x0..0x10FFFF;

                                // that is, 16-bit codes plus 32-bit codes that can be expressed using

                                // 16-bit surrogates

        EOutputBufferOverflow   // output buffer is not big enough

        };

    static void Panic(TPanic aPanic);

    protected:

    enum

        {

        EStaticWindows = 8,

        EDynamicWindows = 8,

        ESpecialBases = 7

        };

    TBool iUnicodeMode;                                 // TRUE if in Unicode mode as opposed to single-byte mode

    TUint32 iActiveWindowBase;                          // base of the active window - bases are 32-bit because they

                                                        // can be set to the surrogate area, which represents codes

                                                        // from 0x00010000 to 0x0010FFFF - planes 1-16 of ISO-10646.

    static const TUint32 iStaticWindow[EStaticWindows]; // bases of the static windows

    static const TUint32 iDynamicWindowDefault[EDynamicWindows];    // default bases of the dynamic windows

    static const TUint16 iSpecialBase[ESpecialBases];   // bases for window offsets F9..FF

    TUint32 iDynamicWindow[EDynamicWindows];            // bases of the dynamic windows

    TInt iUnicodeWords;                                 // Unicode words processed; read by compressor, written by expander

    TInt iMaxUnicodeWords;                              // maximum number of Unicode words to read or write

    TInt iCompressedBytes;                              // compressed bytes processed: read by expander, written by compressor

    TInt iMaxCompressedBytes;                           // maximum number of compressed bytes to read or write

    };

/**

@internalComponent

*/

class MUnicodeSource

    {

    public:

    virtual TUint16 ReadUnicodeValueL() = 0;

    };

/**

@internalComponent

A class to read Unicode values directly from memory.

*/

class TMemoryUnicodeSource: public MUnicodeSource

    {

    public:

    inline TMemoryUnicodeSource(const TUint16* aPtr);

    inline TUint16 ReadUnicodeValueL();

    private:

    const TUint16* iPtr;

    };

/**

@internalComponent

A class to read Unicode values from a stream built on a memory object.

*/

class TMemoryStreamUnicodeSource: public MUnicodeSource

    {

    public:

    inline TMemoryStreamUnicodeSource(CStoreReadStream& aStream);

    inline TUint16 ReadUnicodeValueL();

    private:

    CStoreReadStream& iStream;

    };

/**

@internalComponent

*/

class MUnicodeSink

    {

    public:

    virtual void WriteUnicodeValueL(TUint16 aValue) = 0;

    };

/**

@internalComponent

A class to write Unicode values directly to memory.

*/

class TMemoryUnicodeSink: public MUnicodeSink

    {

    public:

    inline TMemoryUnicodeSink(TUint16* aPtr);

    inline void WriteUnicodeValueL(TUint16 aValue);

    private:

    TUint16* iPtr;

    };

/**

@internalComponent

A class to write Unicode values to a stream built on a memory object.

*/

class TMemoryStreamUnicodeSink: public MUnicodeSink

    {

    public:

    inline TMemoryStreamUnicodeSink(CStoreWriteStream& aStream);

    inline void WriteUnicodeValueL(TUint16 aValue);

    private:

    CStoreWriteStream& iStream;

    };

/**

@internalComponent

A class to hold functions to compress text using the Standard Compression Scheme for Unicode.

*/

class TUnicodeCompressor: public TUnicodeCompressionState

    {

    public:

    TUnicodeCompressor();

    void CompressL(CStoreWriteStream& aOutput,MUnicodeSource& aInput,

                            TInt aMaxOutputBytes = KMaxTInt,TInt aMaxInputWords = KMaxTInt,

                            TInt* aOutputBytes = static_cast<TInt*>(NULL),TInt* aInputWords = static_cast<TInt*>(NULL));

    void CompressL(TUint8* aOutput,MUnicodeSource& aInput,

                            TInt aMaxOutputBytes = KMaxTInt,TInt aMaxInputWords = KMaxTInt,

                            TInt* aOutputBytes = static_cast<TInt*>(NULL),TInt* aInputWords = static_cast<TInt*>(NULL));

    TInt FlushL(CStoreWriteStream& aOutput,TInt aMaxOutputBytes,TInt& aOutputBytes);

    TInt FlushL(TUint8* aOutput,TInt aMaxOutputBytes,TInt& aOutputBytes);

    static TInt CompressedSizeL(MUnicodeSource& aInput,TInt aInputWords);

    private:

     // A structure to store a character and its treatment code

    struct TAction

        {

        // Treatment codes: static and dynamic window numbers, plain ASCII or plain Unicode

        enum

            {

            EPlainUnicode = -2, // character cannot be expressed as ASCII or using static or dynamic windows

            EPlainASCII = -1,   // character can be emitted as an ASCII code

            EFirstDynamic = 0,  // values 0..255 are for dynamic windows with offsets at these places in the offset table

            ELastDynamic = 255,

            EFirstStatic = 256, // values 256..263 are for static windows 0..7

            ELastStatic = 263

            };

        inline TAction();

        TAction(TUint16 aCode);

        TUint16 iCode;      // Unicode value of the character

        TInt iTreatment;    // treatment code: see above

        };

    void DoCompressL(CStoreWriteStream* aOutputStream,TUint8* aOutputPointer,MUnicodeSource* aInput,

                     TInt aMaxCompressedBytes,TInt aMaxUnicodeWords,

                     TInt* aCompressedBytes,TInt* aUnicodeWords);

    void FlushInputBufferL();

    void FlushOutputBufferL();

    void WriteRunL();

    void WriteCharacter(const TAction& aAction);

    void WriteSCharacter(const TAction& aAction);

    void WriteUCharacter(TUint16 aCode);

    void WriteByte(TUint aByte);

    void WriteCharacterFromBuffer();

    void SelectTreatment(TInt aTreatment);

    enum

        {

        EMaxInputBufferSize = 4,

        EMaxOutputBufferSize = EMaxInputBufferSize * 3  // no Unicode character can be encoded as more than three bytes

        };

    TAction iInputBuffer[EMaxInputBufferSize];          // circular buffer; queue of Unicode characters to be processed

    TInt iInputBufferStart;                             // position of first Unicode character to be processed

    TInt iInputBufferSize;                              // characters in the input buffer

    TUint8 iOutputBuffer[EMaxOutputBufferSize];         // circular buffer; queue of compressed bytes to be output

    TInt iOutputBufferStart;                            // position of first compressed byte to be output

    TInt iOutputBufferSize;                             // characters in the output buffer

    TInt iDynamicWindowIndex;                           // index of the current dynamic window

    CStoreWriteStream* iOutputStream;                        // if non-null, output is to this stream

    TUint8* iOutputPointer;                             // if non-null, output is to memory

    MUnicodeSource* iInput;                             // input object

    };

/**

@internalComponent

A class to hold functions to expand text using the Standard Compression Scheme for Unicode.

*/

class TUnicodeExpander: public TUnicodeCompressionState

    {

    public:

    TUnicodeExpander();

    void ExpandL(MUnicodeSink& aOutput,CStoreReadStream& aInput,

                          TInt aMaxOutputWords = KMaxTInt,TInt aMaxInputBytes = KMaxTInt,

                          TInt* aOutputWords = static_cast<TInt*>(NULL),TInt* aInputBytes = static_cast<TInt*>(NULL));

    void ExpandL(MUnicodeSink& aOutput,const TUint8* aInput,

                          TInt aMaxOutputWords = KMaxTInt,TInt aMaxInputBytes = KMaxTInt,

                          TInt* aOutputWords = static_cast<TInt*>(NULL),TInt* aInputBytes = static_cast<TInt*>(NULL));

    TInt FlushL(MUnicodeSink& aOutput,TInt aMaxOutputWords,TInt& aOutputWords);

    static TInt ExpandedSizeL(CStoreReadStream& aInput,TInt aInputBytes);

    static TInt ExpandedSizeL(const TUint8* aInput,TInt aInputBytes);

    private:

    void DoExpandL(MUnicodeSink* aOutput,CStoreReadStream* aInputStream,const TUint8* aInputPointer,

                   TInt aMaxOutputWords,TInt aMaxInputBytes,

                   TInt* aOutputWords,TInt* aInputBytes);

    void HandleByteL();

    void FlushOutputBufferL();

    TBool HandleSByteL(TUint8 aByte);

    TBool HandleUByteL(TUint8 aByte);

    TBool ReadByteL(TUint8& aByte);

    TBool QuoteUnicodeL();

    TBool DefineWindowL(TInt aIndex);

    TBool DefineExpansionWindowL();

    void WriteChar(TText aChar);

    void WriteChar32(TUint aChar);

    enum

        {

        EMaxInputBufferSize = 3,                        // no Unicode character can be encoded as more than 3 bytes

        EMaxOutputBufferSize = 2                        // no byte can be expanded into more than 2 Unicode characters

        };

    TUint8 iInputBuffer[EMaxInputBufferSize];           // buffer containing a group of compressed bytes representing

                                                        // a single operation; when an input source ends in the

                                                        // middle of an operation, this buffer enables the next

                                                        // expansion to start in the correct state

    TInt iInputBufferStart;                             // next read position in the input buffer

    TInt iInputBufferSize;                              // bytes in the input buffer

    TUint16 iOutputBuffer[EMaxOutputBufferSize];        // circular buffer; queue of Unicode characters to be output

    TInt iOutputBufferStart;                            // position of first Unicode character to be output

    TInt iOutputBufferSize;                             // characters in the output buffer

    MUnicodeSink* iOutput;                              // output object

    CStoreReadStream* iInputStream;                          // if non-null, input is from this stream

    const TUint8* iInputPointer;                        // if non-null, input is from memory

    };

// inline functions start here

inline TMemoryUnicodeSource::TMemoryUnicodeSource(const TUint16* aPtr):

    iPtr(aPtr)

    {

    }

inline TUint16 TMemoryUnicodeSource::ReadUnicodeValueL()

    {

    return *iPtr++;

    }

inline TMemoryStreamUnicodeSource::TMemoryStreamUnicodeSource(CStoreReadStream& aStream):

    iStream(aStream)

    {

    }

inline TUint16 TMemoryStreamUnicodeSource::ReadUnicodeValueL()

    {

    TUint16 x;

    iStream.Read(reinterpret_cast<TUint8*>(&x),sizeof(TUint16));

    return x;

    }

inline TMemoryUnicodeSink::TMemoryUnicodeSink(TUint16* aPtr):

    iPtr(aPtr)

    {

    }

inline void TMemoryUnicodeSink::WriteUnicodeValueL(TUint16 aValue)

    {

    *iPtr++ = aValue;

    }

inline TMemoryStreamUnicodeSink::TMemoryStreamUnicodeSink(CStoreWriteStream& aStream):

    iStream(aStream)

    {

    }

inline void TMemoryStreamUnicodeSink::WriteUnicodeValueL(TUint16 aValue)

    {

    iStream.Write(reinterpret_cast<TUint8*>(&aValue),sizeof(TUint16));

    }

inline TUnicodeCompressor::TAction::TAction():

    iCode(0),

    iTreatment(EPlainUnicode)

    {

    }

}

#endif // !defined(__UNICODECOMPRESSION_H__)