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