// 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:

//

#include <s32ucmp.h>

#include "US_STD.H"

//

// Panic the process with STORE-Stream as the category.

//

	{

	_LIT(KCategory,"STORE-Stream");

	User::Panic(KCategory,aPanic);

	}

EXPORT_C void TCardinality::ExternalizeL(RWriteStream& aStream) const

/** Externalises this object to a write stream.

The existence of this function means that the standard templated operator<<() 

can be used to externalise objects of this class.

@param aStream Stream to which the object should be externalised.

@see operator<<() */

	{

	TUint n=iCount;

	if (n<=(KMaxTUint8>>KShiftCardinality8))

		aStream.WriteUint8L((n<<KShiftCardinality8));

	else if (n<=(KMaxTUint16>>KShiftCardinality16))

		aStream.WriteUint16L((n<<KShiftCardinality16)+0x1);

	else

		{

		__ASSERT_DEBUG(n<=(TUint)KMaxCardinality,Panic(EStreamCardinalityOutOfRange));

		aStream.WriteUint32L((n<<KShiftCardinality32)+0x3);

		}

	}

EXPORT_C void TCardinality::InternalizeL(RReadStream& aStream)

/** Internalizes this object from a read stream.

The existence of this function means that the standard templated operator>>() 

can be used to internalise objects of this class.

@param aStream Stream store from which the objet is to be internalised.

@see operator>>() */

	{

	TUint n=aStream.ReadUint8L();

	if ((n&0x1)==0)

		n>>=KShiftCardinality8;

	else if ((n&0x2)==0)

		{

		n+=aStream.ReadUint8L()<<8;

		n>>=KShiftCardinality16;

		}

	else if ((n&0x4)==0)

		{

		aStream.ReadL((TUint8*)&iCount,sizeof(TUint32)-sizeof(TUint8));

		n+=TUint(iCount)<<8; // platform dependency

		n>>=KShiftCardinality32;

		}

	else

		__LEAVE(KErrCorrupt);

//

	__ASSERT_DEBUG(n<=(TUint)KMaxCardinality,User::Invariant());

	iCount=n;

	}

// An MUnicodeSink implementation to write Unicode values into 8-bit bytes; anything outside 0..255 becomes 1

#ifdef _UNICODE

class TNarrowUnicodeSink: public MUnicodeSink

	{

	public:

	TNarrowUnicodeSink(TUint8* aPtr): iPtr(aPtr) { }

	void WriteUnicodeValueL(TUint16 aValue) { *iPtr++ = (TUint8)(aValue > 255 ? 1 : aValue); }

	private:

	TUint8* iPtr;

	};

#endif

void TDesInternalizer::operator()(TDes8& aDes8,RReadStream& aStream) const

//

// Read an 8-bit descriptor in from aStream.

//

	{

	TInt len=iHeader.Length();

	if (len>aDes8.MaxLength())

		__LEAVE(KErrOverflow);

//

	TUint8* ptr=(TUint8*)aDes8.Ptr();

	if (iHeader.IsWidth8())

		aStream.ReadL(ptr,len);

	else

		{

		__ASSERT_DEBUG(iHeader.IsWidth16(),User::Invariant());

#ifdef _UNICODE

		// In the Unicode build 16-bit descriptors need to be expanded from the Standard Unicode Compression Scheme.

		TNarrowUnicodeSink sink(ptr);

		TUnicodeExpander expander;

		expander.ExpandL(sink,aStream,len);

#else

		TUint8* end=ptr+len;

		while (ptr!=end)

			{

			TUint c=aStream.ReadUint16L();

			if (c>=0x100)

				c=1;

			*ptr++=TUint8(c);

			}

#endif

		}

	aDes8.SetLength(len);

	}

void TDesInternalizer::operator()(TDes16& aDes16,RReadStream& aStream) const

//

// Read a 16-bit descriptor in from aStream.

//

	{

	TInt len=iHeader.Length();

	if (len>aDes16.MaxLength())

		__LEAVE(KErrOverflow);

//

	TUint16* ptr=(TUint16*)aDes16.Ptr();

	if (iHeader.IsWidth16())

		{

#ifdef _UNICODE

		// In the Unicode build 16-bit descriptors need to be expanded from the Standard Unicode Compression Scheme.

		TMemoryUnicodeSink sink(ptr);

		TUnicodeExpander expander;

		expander.ExpandL(sink,aStream,len);

#else

		aStream.ReadL(ptr,len);

#endif

		}

	else

		{

		__ASSERT_DEBUG(iHeader.IsWidth8(),User::Invariant());

		TUint16* end=ptr+len;

		while (ptr!=end)

			*ptr++=aStream.ReadUint8L();

		}

	aDes16.SetLength(len);

	}

EXPORT_C void TStreamTransfer::__DbgChkNonNegative(TInt aLength)

//

// Check for a negative value.

//

	{

	__ASSERT_ALWAYS(aLength>=0,Panic(EStreamTransferNegative));

	}

EXPORT_C void TCardinality::__DbgChkRange(TInt aCount)

//

// Check for a negative count.

//

	{

	__ASSERT_ALWAYS(aCount<=KMaxCardinality,Panic(EStreamCardinalityOutOfRange));

	}