/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 <e32base.h>

#include <errno.h>

#include "stringconv.h"

#include "logger.h"

#include <f32file.h>

void Panic(TInt aCode)

{

	dbg << Log::Indent() << "Panic(" << aCode << ")" << Log::Endl();

	FatalError();

}

void User::LeaveIfError(TInt aError)

{

	if(aError<0) User::Leave(aError);

}

void User::Invariant()

{ 

	FatalError();

}

void User::Panic(const TDesC &aCategory, TInt aReason) 

{ 

	dbg << Log::Indent() << "User::Panic('" << stringFromUtf16(aCategory) << "'," << aReason << ") called" << Log::Endl();

	FatalError(); 

}

void User::Leave(TInt aReason) 

{ 

	dbg << Log::Indent() << "User::Leave(" << aReason << ") - Not supported by this port" << Log::Endl();

	FatalError(); 

}

TDesC8::TDesC8()

	: iCurrentLength(0)

{

}

TDesC8::TDesC8(const TDesC8 &aRef)

	: iCurrentLength(aRef.iCurrentLength)

{

}

TDesC8::TDesC8(TInt aLength)

	: iCurrentLength(aLength)

{

}

TBool TDesC8::operator==(const TDesC8 &aDes) const

{

	if(Length() != aDes.Length())

		{

		return EFalse;

		}

	if(memcmp(Ptr(), aDes.Ptr(), Length()) == 0)

		{

		return ETrue; // Identical

		}

	return EFalse;

}

TDes8::TDes8()

	: TDesC8(0), iMaxLength(0)

{

}

TDes8::TDes8(const TDes8 &aRef)

	: TDesC8(aRef), iMaxLength(aRef.iMaxLength)

{

}

TDes8::TDes8(TInt aLength,TInt aMaxLength)

	: TDesC8(aLength), iMaxLength(aMaxLength)

{

}

void TDes8::Copy(const TDesC16 &aDes)

{

	TInt len=aDes.Length();

	SetLength(len);

	const TUint16 *pS=aDes.Ptr();

	const TUint16 *pE=pS+len;

	TUint8 *pT=const_cast<TUint8 *>(Ptr());

	while (pS<pE)

		{

		TUint c=(*pS++);

		if (c>=0x100)

			c=1;

		*pT++=(TUint8)c;

		}

}

void TDes8::SetLength(TInt aLength)

{

	if(aLength < 0 || aLength > iMaxLength) FatalError();

	iCurrentLength = aLength;

}

TPtr8::TPtr8(const TPtr8 &aRef)

	: TDes8(aRef), iPtr(aRef.iPtr)

{

}

TPtr8 &TPtr8::operator=(const TPtr8 &aRhs)

{

	if(this == &aRhs) return *this; // handle self assignment

	if(aRhs.Length() > MaxLength()) FatalError();

	memcpy(iPtr, aRhs.Ptr(), aRhs.Length());

	SetLength(aRhs.Length());

	return *this;

}

const TUint8 *TPtr8::Ptr() const

{

	return iPtr;

}

const TUint8 &TPtr8::operator[](TInt anIndex) const

{

	if(anIndex < 0 || anIndex >= Length())

		{

		dbg << Log::Indent() << "TPtrC8 bounds check failure" << Log::Endl();

		FatalError();

		}

	return iPtr[anIndex];

}

void TPtr8::Append(TChar aChar)

{

	if(iCurrentLength+1 > iMaxLength)

		{

		dbg << Log::Indent() << "TPtr8::Append range check failure" << Log::Endl();

		FatalError();

		}

	iPtr[iCurrentLength++] = aChar;

}

TPtrC8::TPtrC8(const TPtrC8 &aRef)

	: TDesC8(aRef), iPtr(aRef.iPtr)

{

}

TPtrC8 &TPtrC8::operator=(const TPtrC8 &aRhs)

{

	if(this == &aRhs) return *this; // handle self assignment

	if(aRhs.Length() > Length()) FatalError();

	memcpy(const_cast<TUint8 *>(iPtr), aRhs.Ptr(), aRhs.Length());

	return *this;

}

void TPtrC8::Set(TUint8 *aBuf, TInt aLength)

{

	iPtr = aBuf,

	iCurrentLength = aLength;

}

const TUint8 *TPtrC8::Ptr() const

{

	return iPtr;

}

const TUint8 &TPtrC8::operator[](TInt anIndex) const

{

	if(anIndex < 0 || anIndex >= Length())

		{

		dbg << Log::Indent() << "TPtrC8 bounds check failure" << Log::Endl();

		FatalError();

		}

	return iPtr[anIndex];

}

TDesC16::TDesC16()

	: iCurrentLength(0)

{

}

TDesC16::TDesC16(const TDesC16 &aRef)

	: iCurrentLength(aRef.iCurrentLength)

{

}

TDesC16::TDesC16(TInt aLength)

	: iCurrentLength(aLength)

{

}

TDes16::TDes16()

	: TDesC16(0), iMaxLength(0)

{

}

TDes16::TDes16(const TDes16 &aRef)

	: TDesC16(aRef), iMaxLength(aRef.iMaxLength)

{

}

TDes16::TDes16(TInt aLength,TInt aMaxLength)

	: TDesC16(aLength), iMaxLength(aMaxLength)

{

}

void TDes16::SetLength(TInt aLength)

{

	if(aLength < 0 || aLength > iMaxLength) FatalError();

	iCurrentLength = aLength;

}

TBool TDesC16::operator==(const TDesC8 &aDes) const

{

	if(Length() != aDes.Length())

		{

		return EFalse;

		}

	if(memcmp(Ptr(), aDes.Ptr(), Length()*2) == 0)

		{

		return ETrue; // Identical

		}

	return EFalse;

}

TPtrC16::TPtrC16(const TPtrC16 &aRef)

	: TDesC16(aRef), iPtr(aRef.iPtr)

{

}

TPtrC16 &TPtrC16::operator=(const TPtrC16 &aRhs)

{

	if(this == &aRhs) return *this; // handle self assignment

	if(aRhs.Length() > Length()) FatalError();

	memcpy(const_cast<TUint16 *>(iPtr), aRhs.Ptr(), aRhs.Length()*2);

	return *this;

}

void TPtrC16::Set(TUint16 *aBuf, TInt aLength)

{

	iPtr = aBuf,

	iCurrentLength = aLength;

}

const TUint16 *TPtrC16::Ptr() const

{

	return iPtr;

}

const TUint16 &TPtrC16::operator[](TInt anIndex) const

{

	if(anIndex < 0 || anIndex >= Length())

		{

		dbg << Log::Indent() << "TPtrC16 bounds check failure" << Log::Endl();

		FatalError();

		}

	return iPtr[anIndex];

}

TPtr16::TPtr16(const TPtr16 &aRef)

	: TDes16(aRef), iPtr(aRef.iPtr)

{

}

TPtr16 &TPtr16::operator=(const TPtr16 &aRhs)

{

	if(this == &aRhs) return *this; // handle self assignment

	if(aRhs.Length() > MaxLength()) FatalError();

	memcpy(iPtr, aRhs.Ptr(), aRhs.Length()*sizeof(TUint16));

	SetLength(aRhs.Length());

	return *this;

}

void TPtr16::Copy(const TDesC8 &aDes)

{

	// This is not quite 100% compatible because it does a correct

	// UTF-8 to UCS-2 conversion, instead of just stuffing in zeros.

	TInt outLength = 0;

	TText *outBuf = utf16FromUtf8(aDes.Ptr(), aDes.Length(), outLength);

	if(outLength > MaxLength()) FatalError();

	memcpy(iPtr, outBuf, outLength*2);

	SetLength(outLength);

	delete [] outBuf;

}

const TUint16 *TPtr16::Ptr() const

{

	return iPtr;

}

const TUint16 &TPtr16::operator[](TInt anIndex) const

{

	if(anIndex < 0 || anIndex >= Length())

		{

		dbg << Log::Indent() << "TPtr16 bounds check failure" << Log::Endl();

		FatalError();

		}

	return iPtr[anIndex];

}

void TPtr16::Append(TChar aChar)

{

	if(iCurrentLength+1 > iMaxLength)

		{

		dbg << Log::Indent() << "TPtr16::Append range check failure" << Log::Endl();

		FatalError();

		}

	iPtr[iCurrentLength++] = aChar;

}

TLIT16::TLIT16(const char *aStr)

	: iDes(0,0)

{

	// Expand UTF-8 into internal UTF-16LE representation

	TInt outputWords = 0;

	TText *outputBuf = utf16FromUtf8((TUint8 *)aStr, strlen(aStr), outputWords);

	// Work out actual string length and save the buffer and ptr in out descriptor

	iDes.Set(outputBuf, outputWords);

}

TLIT16::TLIT16(const TLIT16 &aRef)

	: iDes(aRef.iDes.Ptr(), aRef.iDes.Length())

{

}

TLIT16::~TLIT16()

{

	// May leak here, but TLITs should be at global scope anyway...

}

const TDesC16* TLIT16::operator&() const

{

	return &iDes;

}

TLIT16::operator const TDesC16&() const

{

	return iDes;

}

const TDesC16& TLIT16::operator()() const

{

	return iDes;

}

TLIT8::TLIT8(const char *aStr)

	: TPtrC8((const TUint8 *)aStr, strlen(aStr))

{

}

TLIT8::TLIT8(const TLIT8 &aRef)

	: TPtrC8(aRef)

{

}

void CleanupStack::PopAndDestroy(RArrayBase *aRArray)

{

	aRArray->Close();

}

void CleanupStack::PopAndDestroy(RFs *aFs)

{

	aFs->Close();

}

void PushL(void *)

{

}

// End of file