// descriptorJuggling.cpp

// 

// Copyright (c) 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <fshell/ltkutils.h>

#include <fshell/descriptorutils.h>

#include <u32std.h>

const TUint16 KReplacementChar = 0xFFFD;

const TUint16 KBom = 0xFEFF;

_LIT8(KReplacementCharInUtf8, "\xEF\xBF\xBD");

using namespace LtkUtils;

// This class is used to track state between invocations of AppendUtf8L().

namespace LtkUtils

	{

	class TUtf8State

		{

	public:

		TUtf8State();

	public:

		TInt iFirstUnconvertedByte;

		TInt iBytesConsumedSoFar;

		TUint8 iUnconvertedBytesCount;

		TUint8 iUnconvertedBytes[3]; // A UTF-8 sequence is a maximum of 4 bytes long so there can only be a max of 3 bytes unconverted

		};

	} // end namespace LtkUtils

const TInt KStateCharCount = sizeof(LtkUtils::TUtf8State) / sizeof(TUint16);

__ASSERT_COMPILE((sizeof(LtkUtils::TUtf8State) & 3) == 0);

__ASSERT_COMPILE(KStateCharCount == 6); // Just checking I've done my maths right, it doesn't particularly have to be this size

EXPORT_C TUint LtkUtils::HexLexL(TLex16& aLex)

	{

	TUint result;

	User::LeaveIfError(HexLex(aLex, result));

	return result;

	}

EXPORT_C TInt LtkUtils::HexLex(TLex16& aLex, TUint& aResult)

	{

	_LIT(KHexPrefix, "0x");

	if (aLex.Remainder().Length() > 2)

		{

		TLexMark16 mark;

		aLex.Mark(mark);

		aLex.Inc(2);

		TPtrC prefix(aLex.MarkedToken(mark));

		if (prefix == KHexPrefix)

			{

			TInt err = aLex.Val(aResult, EHex);

			if (err) aLex.UnGetToMark(mark); // Make sure we leave it at the original position if error

			return err;

			}

		else

			{

			aLex.UnGetToMark(mark);

			}

		}

	return aLex.Val(aResult, EDecimal);

	}

EXPORT_C TUint LtkUtils::HexLexL(TLex8& aLex)

	{

	TUint result;

	User::LeaveIfError(HexLex(aLex, result));

	return result;

	}

EXPORT_C TInt LtkUtils::HexLex(TLex8& aLex, TUint& aResult)

	{

	_LIT8(KHexPrefix, "0x");

	if (aLex.Remainder().Length() > 2)

		{

		TLexMark8 mark;

		aLex.Mark(mark);

		aLex.Inc(2);

		TPtrC8 prefix(aLex.MarkedToken(mark));

		if (prefix == KHexPrefix)

			{

			TInt err = aLex.Val(aResult, EHex);

			if (err) aLex.UnGetToMark(mark); // Make sure we leave it at the original position if error

			return err;

			}

		else

			{

			aLex.UnGetToMark(mark);

			}

		}

	return aLex.Val(aResult, EDecimal);

	}

EXPORT_C TInt LtkUtils::ReplaceText(TDes& aDescriptor, const TDesC& aFrom, const TDesC& aTo)

	{

	TInt numReplaced = 0;

	TInt pos = 0;

	const TInt lenDelta = -aFrom.Length() + aTo.Length();

	while (ETrue)

		{

		TPtrC des(aDescriptor.Mid(pos));

		TInt found = des.Find(aFrom);

		if (found == KErrNotFound) break;

		TInt idx = pos + found;

		if (aDescriptor.Length() + lenDelta > aDescriptor.MaxLength()) return KErrOverflow;

		aDescriptor.Replace(idx, aFrom.Length(), aTo);

		pos = idx + aTo.Length();

		numReplaced++;

		}

	return numReplaced;

	}

void EnsureCapacityL(HBufC*& aBuf, TInt aExtra)

	{

	if (aBuf->Length() + aExtra > aBuf->Des().MaxLength())

		{

		aBuf = aBuf->ReAllocL(aBuf->Length() + aExtra);

		}

	}

EXPORT_C TBool LtkUtils::HasPrefix(const TDesC16& aDes, const TDesC16& aPrefix)

	{

	return aDes.Left(aPrefix.Length()) == aPrefix;

	}

EXPORT_C TBool LtkUtils::HasPrefix(const TDesC8& aDes, const TDesC8& aPrefix)

	{

	return aDes.Left(aPrefix.Length()) == aPrefix;

	}

#define KB *1024

#define MB *1024*1024

#define GB *1024*1024*1024

EXPORT_C void LtkUtils::FormatSize(TDes16& aDes, TInt64 aSize)

	{

	_LIT(KBytes, " B");

	_LIT(KKilobytes, " KB");

	_LIT(KMegabytes, " MB");

	_LIT(KGigabytes, " GB");

	const TDesC* suff = &KBytes;

	TReal n = aSize;

	TInt factor = 1;

	TInt64 absSize = aSize;

	if (absSize < 0) absSize = -absSize;

	if (absSize >= 1 GB)

		{

		suff = &KGigabytes;

		factor = 1 GB;

		}

	else if (absSize >= 1 MB)

		{

		suff = &KMegabytes;

		factor = 1 MB;

		}

	else if (absSize >= 1 KB)

		{

		suff = &KKilobytes;

		factor = 1 KB;

		}

	n = n / (TReal)factor;

	TBool wholeNumUnits = (absSize & (factor-1)) == 0; // ie aSize % factor == 0

	TRealFormat fmt(aDes.MaxLength(), wholeNumUnits ? 0 : 2);

	aDes.Num(n, fmt);

	aDes.Append(*suff);

	}

EXPORT_C void LtkUtils::FormatSize(TDes8& aDes, TInt64 aSize)

	{

	TBuf<32> buf;

	FormatSize(buf, aSize);

	aDes.Copy(buf);

	}

// RLtkBuf follows

inline TDesC16::TDesC16(TInt aType,TInt aLength)

	:iLength(aLength|(aType<<KShiftDesType16))

	{}

inline TDes16::TDes16(TInt aType,TInt aLength,TInt aMaxLength)

	: TDesC16(aType,aLength),iMaxLength(aMaxLength)

	{}

EXPORT_C LtkUtils::RLtkBuf16::RLtkBuf16()

	: TDes16(EPtr,0,0), iBuf(NULL)

	{

	}

EXPORT_C LtkUtils::RLtkBuf16::RLtkBuf16(HBufC16* aBuf)

	{

	if(aBuf)

		{

		//Create EBufCPtr type descriptor that points to aHBuf

		// I'll take base_e32's word for it that this does the right thing...

		new(this) TPtr16(aBuf->Des());

		}

	else

		{

		//Create zero-length RBuf16. It is EPtr type of descriptor that points to NULL.

		new(this) RLtkBuf16();

		}

	}

EXPORT_C HBufC16* LtkUtils::RLtkBuf16::ToHBuf()

	{

	// This transfers ownership

	HBufC16* result = iBuf;

	Assign(NULL);

	return result;

	}

EXPORT_C HBufC16* LtkUtils::RLtkBuf16::GetHBuf() const

	{

	// This doesn't transfer ownership

	return iBuf;

	}

EXPORT_C TInt LtkUtils::RLtkBuf16::ReAlloc(TInt aMaxLength)

	{

	if (!aMaxLength) // Reallocation to zero length

		{

		Close();

		return KErrNone;

		}

	if (!iBuf) // Reallocation from zero length

		return Create(aMaxLength); 

	// Need to maintain the UTF-8 state trickery

	TUtf8State* oldState = GetUtf8State();

	if (oldState)

		{

		TUtf8State state = *oldState;

		HBufC16* newbuf = iBuf->ReAlloc(aMaxLength + KStateCharCount);

		if (!newbuf) return KErrNoMemory;

		Assign(newbuf); // This will set iMaxLength

		iMaxLength = iMaxLength - KStateCharCount;

		Mem::Copy((TAny*)(Ptr() + MaxLength()), &state, sizeof(TUtf8State));

		}

	else

		{

		HBufC16* newbuf = iBuf->ReAlloc(aMaxLength);

		if (!newbuf) return KErrNoMemory;

		Assign(newbuf);

		}

	return KErrNone;

	}

EXPORT_C void LtkUtils::RLtkBuf16::ReAllocL(TInt aMaxLength)

	{

	User::LeaveIfError(ReAlloc(aMaxLength));

	}

EXPORT_C void LtkUtils::RLtkBuf16::Assign(HBufC16* aBuf)

	{

	new(this) RLtkBuf16(aBuf);

	}

EXPORT_C TInt LtkUtils::RLtkBuf16::Create(TInt aMaxLength)

	{

	if (aMaxLength)

		{

		HBufC16* buf = HBufC16::New(aMaxLength);

		if (!buf) return KErrNoMemory;

		Assign(buf);

		}

	else

		{

		Assign(NULL);

		}

	return KErrNone;

	}

EXPORT_C void LtkUtils::RLtkBuf16::CreateL(TInt aMaxLength)

	{

	User::LeaveIfError(Create(aMaxLength));

	}

EXPORT_C void LtkUtils::RLtkBuf16::CreateLC(TInt aMaxLength)

	{

	CleanupClosePushL(*this);

	User::LeaveIfError(Create(aMaxLength));

	}

EXPORT_C void LtkUtils::RLtkBuf16::Close()

	{

	delete iBuf;

	Assign(NULL);

	}

EXPORT_C void LtkUtils::RLtkBuf16::AppendL(const TDesC16& aText)

	{

	ReserveExtraL(aText.Length());

	Append(aText);

	}

EXPORT_C void LtkUtils::RLtkBuf16::AppendL(TChar aChar)

	{

	ReserveExtraL(1);

	Append(aChar);

	}

EXPORT_C void LtkUtils::RLtkBuf16::ReplaceAllL(const TDesC16& aFrom, const TDesC16& aTo)

	{

	//TInt numReplaced = 0;

	TInt pos = 0;

	const TInt lenDelta = -aFrom.Length() + aTo.Length();

	while (ETrue)

		{

		TPtrC16 des(Mid(pos));

		TInt found = des.Find(aFrom);

		if (found == KErrNotFound) break;

		TInt idx = pos + found;

		TInt neededLen = Length() + lenDelta;

		if (neededLen > MaxLength())

			{

			neededLen = Max(neededLen, MaxLength()*2);

			ReAllocL(neededLen);

			}

		Replace(idx, aFrom.Length(), aTo);

		pos = idx + aTo.Length();

		//numReplaced++;

		}

	}

EXPORT_C void LtkUtils::RLtkBuf16::ReplaceL(TInt aPos, TInt aLength, const TDesC16 &aDes)

	{

	const TInt lenDelta = -aLength + aDes.Length();

	ReserveExtraL(lenDelta);

	Replace(aPos, aLength, aDes);

	}

EXPORT_C TInt LtkUtils::RLtkBuf16::CreateMax(TInt aMaxLength)

	{

	TInt err = Create(aMaxLength);

	if (!err) SetLength(aMaxLength);

	return err;

	}

EXPORT_C void LtkUtils::RLtkBuf16::CreateMaxL(TInt aMaxLength)

	{

	User::LeaveIfError(CreateMax(aMaxLength));

	}

class TOverflowDetect : public TDes16Overflow

	{

public:

	TOverflowDetect() : iOverflowed(EFalse) {}

	virtual void Overflow(TDes16& /*aDes*/) { iOverflowed = ETrue; }

	TBool iOverflowed;

	};

EXPORT_C void LtkUtils::RLtkBuf16::AppendFormatL(TRefByValue<const TDesC16> aFmt, ...)

	{

	TInt origLen = Length();

	for (;;)

		{

		VA_LIST args;

		VA_START(args, aFmt);

		TOverflowDetect overflow;

		AppendFormatList(aFmt, args, &overflow);

		VA_END(args);

		if (overflow.iOverflowed)

			{

			SetLength(origLen); // In case we got half-way through formatting

			ReAllocL(Max(16, MaxLength() * 2));

			// And go round again

			}

		else

			{

			// We're done, no overflow

			break;

			}

		}

	}

EXPORT_C void LtkUtils::RLtkBuf16::ReserveExtraL(TInt aExtraCapacity)

	{

	User::LeaveIfError(ReserveExtra(aExtraCapacity));

	}

EXPORT_C TInt LtkUtils::RLtkBuf16::ReserveExtra(TInt aExtraCapacity)

	{

	if (Length() + aExtraCapacity > MaxLength())

		{

		TInt newlen = Max(Length() + aExtraCapacity, (MaxLength() * 3)/2);

		return ReAlloc(newlen);

		}

	return KErrNone;

	}

inline TDesC8::TDesC8(TInt aType,TInt aLength)

	:iLength(aLength|(aType<<KShiftDesType8))

	{}

inline TDes8::TDes8(TInt aType,TInt aLength,TInt aMaxLength)

	: TDesC8(aType,aLength),iMaxLength(aMaxLength)

	{}

EXPORT_C LtkUtils::RLtkBuf8::RLtkBuf8()

	: TDes8(EPtr,0,0), iBuf(NULL)

	{

	}

EXPORT_C LtkUtils::RLtkBuf8::RLtkBuf8(HBufC8* aBuf)

	{

	if(aBuf)

		{

		//Create EBufCPtr type descriptor that points to aHBuf

		// I'll take base_e32's word for it that this does the right thing...

		new(this) TPtr8(aBuf->Des());

		}

	else

		{

		//Create zero-length RBuf8. It is EPtr type of descriptor that points to NULL.

		new(this) RLtkBuf8();

		}

	}

EXPORT_C HBufC8* LtkUtils::RLtkBuf8::ToHBuf()

	{

	// This transfers ownership

	HBufC8* result = iBuf;

	Assign(NULL);

	return result;

	}

EXPORT_C HBufC8* LtkUtils::RLtkBuf8::GetHBuf() const

	{

	// This doesn't transfer ownership

	return iBuf;

	}

EXPORT_C TInt LtkUtils::RLtkBuf8::ReAlloc(TInt aMaxLength)

	{

	if (!aMaxLength) // Reallocation to zero length

		{

		Close();

		return KErrNone;

		}

	if (!iBuf) // Reallocation from zero length

		return Create(aMaxLength); 

	HBufC8* newbuf = iBuf->ReAlloc(aMaxLength);

	if (!newbuf) return KErrNoMemory;

	Assign(newbuf);

	return KErrNone;

	}

EXPORT_C void LtkUtils::RLtkBuf8::ReAllocL(TInt aMaxLength)

	{

	User::LeaveIfError(ReAlloc(aMaxLength));

	}

EXPORT_C void LtkUtils::RLtkBuf8::Assign(HBufC8* aBuf)

	{

	new(this) RLtkBuf8(aBuf);

	}

EXPORT_C TInt LtkUtils::RLtkBuf8::Create(TInt aMaxLength)

	{

	if (aMaxLength)

		{

		HBufC8* buf = HBufC8::New(aMaxLength);

		if (!buf) return KErrNoMemory;

		Assign(buf);

		}

	else

		{

		Assign(NULL);

		}

	return KErrNone;

	}

EXPORT_C void LtkUtils::RLtkBuf8::CreateL(TInt aMaxLength)

	{

	User::LeaveIfError(Create(aMaxLength));

	}

EXPORT_C void LtkUtils::RLtkBuf8::CreateLC(TInt aMaxLength)

	{

	CleanupClosePushL(*this);

	User::LeaveIfError(Create(aMaxLength));

	}

EXPORT_C void LtkUtils::RLtkBuf8::Close()

	{

	delete iBuf;

	Assign(NULL);

	}

EXPORT_C void LtkUtils::RLtkBuf8::AppendL(const TDesC8& aText)

	{

	ReserveExtraL(aText.Length());

	Append(aText);

	}

EXPORT_C void LtkUtils::RLtkBuf8::AppendL(TChar aChar)

	{

	ReserveExtraL(1);

	Append(aChar);

	}

EXPORT_C void LtkUtils::RLtkBuf8::ReplaceAllL(const TDesC8& aFrom, const TDesC8& aTo)

	{

	//TInt numReplaced = 0;

	TInt pos = 0;

	const TInt lenDelta = -aFrom.Length() + aTo.Length();

	while (ETrue)

		{