// Copyright (c) 2003-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:
//

/**
 @file
*/

#include "CMtfEnumeratorConverter.h"

_LIT(KMtfEnumeratorSeparator,"::");

/** Takes a full enumerator value and creates a new empty object.
It discards the enumerator value and only uses the class name (optional) and
enumeration name */
CMtfEnumeratorConverter* CMtfEnumeratorConverter::NewL(const TDesC& aEnumeratorValue)
{
	return CMtfEnumeratorConverter::NewL(
		ParseEnumeratorValueL(aEnumeratorValue,EMtfEnumeratorClassName),
		ParseEnumeratorValueL(aEnumeratorValue,EMtfEnumeratorEnumerationName));	
}
	
CMtfEnumeratorConverter* CMtfEnumeratorConverter::NewL(const TDesC& aClassName, const TDesC& aEnumerationName)
{
	CMtfEnumeratorConverter* self = new (ELeave) CMtfEnumeratorConverter();
	CleanupStack::PushL(self);
	self->ConstructL(aClassName,aEnumerationName);
	CleanupStack::Pop(self);
	return self;
}

/** ConstructL allocates the class name and the enumeration name. */
void CMtfEnumeratorConverter::ConstructL(const TDesC& aClassName, const TDesC& aEnumerationName)
{
	iClassName = aClassName.AllocL();
	iEnumerationName = aEnumerationName.AllocL();
}

/** If '::' sequence occurs in the given parameter then it is assumed to be a 
constant enumerator value, as opposed to a parameter name. If KErrNotFound is returned 
the function returns EFalse. If a positive offset or any other error occur the function 
returns ETrue. If an error has occurred (and it is not KErrNotFound) then when this 
parameter is attempted to be used as a constant parameter the error will occur again 
and it will be handled. */
TBool CMtfEnumeratorConverter::IsConstantEnumerator(const TDesC& aParameter)
{
	return (aParameter.Find(KMtfEnumeratorSeparator) != KErrNotFound);
}

/** Takes a full enumerator value and returns the required part. Leaves if the required
part does not exist. 
@param aEnumeratorValue Full enumerator value including the enumerator constant
@param aPart Required part
@return Descriptor containing the required part */
TPtrC CMtfEnumeratorConverter::ParseEnumeratorValueL(const TDesC& aEnumeratorValue,
		TMtfEnumeratorPart aPart)
{
	if (!CMtfEnumeratorConverter::IsConstantEnumerator(aEnumeratorValue))
	{
		// there is no '::' in the string so assume it is a value
		if (aPart != EMtfEnumeratorValueName)
		{
			User::Leave(KErrNotFound);
		}
		
		return aEnumeratorValue;
	}
	
	TPtrC className;
	TPtrC enumerationName;
	TPtrC valueName;
	
	// '::' is a substring of aEnumeratorValue
	TInt offset;
	
	// the string '::' must exist since it is a constant 
	User::LeaveIfError(offset = aEnumeratorValue.Find(KMtfEnumeratorSeparator));
		
	// take the portion of the string from the start to the sequence '::'
	// this is either class name or enumeration name
	TPtrC firstName = aEnumeratorValue.Mid(0,offset);
	
	// move over '::' and take the second part of the string
	TPtrC remainder = aEnumeratorValue.Mid(offset+KMtfEnumeratorSeparator().Length());
	
	// attempt to find a second '::' substring
	TInt secondOffset = remainder.Find(KMtfEnumeratorSeparator);
		
	if (secondOffset == KErrNotFound)
	{	
		// there is no class name, use an empty string
		className.Set(KNullDesC());
		enumerationName.Set(firstName);
		valueName.Set(remainder);
	}
	else if (secondOffset <= 0)
	{
		// some other error has occurred, if 0 then the string ends with '::' which
		// is invalid
		User::Leave(KErrNotFound);
	}
	else
	{
		// class name exists
		className.Set(firstName);
		enumerationName.Set(remainder.Mid(0,secondOffset));
		valueName.Set(remainder.Mid(secondOffset+KMtfEnumeratorSeparator().Length()));
	}
		
	switch(aPart)
	{
		case EMtfEnumeratorClassName:
			return className;
		case EMtfEnumeratorEnumerationName:
			return enumerationName;
		case EMtfEnumeratorValueName:
			return valueName;
		default:
			User::Leave(KErrGeneral);
	}
	
	// dead code but required to prevent a compiler warning
	return valueName;
}
	
CMtfEnumeratorConverter::~CMtfEnumeratorConverter()
{
	delete iClassName;
	delete iEnumerationName;
	iEnumeratorValues.ResetAndDestroy();
	iValues.Reset();
}
	
/** Compares the class name and the enumeration name. Doesn't compare actual
enumerator values. */
TBool CMtfEnumeratorConverter::operator==(const CMtfEnumeratorConverter& aConverter) const
{
	return ((*iClassName == *aConverter.iClassName) && 
			(*iEnumerationName == *aConverter.iEnumerationName));
}

/** Compares the class name and the enumeration name. Doesn't compare actual
enumerator values. */
TBool CMtfEnumeratorConverter::operator!=(const CMtfEnumeratorConverter& aConverter) const
{
	return !(*this==aConverter);
}

/** If the enumerator value already exists then leave, 
otherwise add the new constant/value pair. */
void CMtfEnumeratorConverter::AddEnumeratorValueL(const TDesC& aEnumeratorValue, TInt aValue)
{
	TInt err=0;
	TRAP(err,ConvertL(aEnumeratorValue));
	
	if (err == KErrNone)
	{
		User::Leave(KErrAlreadyExists);
	}
	else if (err != KErrNotFound)
	{
		User::Leave(err);
	}

	User::LeaveIfError(iValues.Append(aValue));
	
	// If AllocL leaves then the object is left in an inconsistent state (there is a 
	// value but no constant associated with that value. That will not cause any problems since
	// if we leave at this point the whole test case will fail.
	
	HBufC* enumeratorValue = aEnumeratorValue.AllocLC();
	User::LeaveIfError(iEnumeratorValues.Append(enumeratorValue));
	CleanupStack::Pop(enumeratorValue);
}
	
/** 
@param aEnumeratorValue Enumerator value to convert. It can be full name (including class name,
enumeration name and constant, or just the constant name. If the value contains '::' then 
it is parsed, otherwise it is assumed to be a constant of this enumeration.
@return Numerical value associated with the constant */
TInt CMtfEnumeratorConverter::ConvertL(const TDesC& aEnumeratorValue) const
{
	TPtrC value = aEnumeratorValue;
	
	// does it contain '::' ?
	if (CMtfEnumeratorConverter::IsConstantEnumerator(aEnumeratorValue))
	{
		// extract the name of the enumerator value
		CMtfEnumeratorConverter* converter = CMtfEnumeratorConverter::NewL(aEnumeratorValue);
		CleanupStack::PushL(converter);
		if (*converter != *this)
		{
			// wrong converter is being used
			User::Leave(KErrNotFound);
		}
		
		value.Set(CMtfEnumeratorConverter::ParseEnumeratorValueL(aEnumeratorValue,EMtfEnumeratorValueName));
		CleanupStack::PopAndDestroy(converter);
	}
	
	TInt i;
	TBool found = EFalse;
	
	TInt count = iEnumeratorValues.Count(); 
	
	for (i=0; i<count; i++)
	{
		if (*iEnumeratorValues[i] == value)
		{
			found = ETrue;
			break;
		}
	}
	
	if (!found)
	{
		User::Leave(KErrNotFound);
	}
	
	return iValues[i];
}
	

CMtfEnumeratorConverter::CMtfEnumeratorConverter()
{
}