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

//

using namespace NCentralRepositoryConstants;

inline TServerSetting::TServerSetting()

	: iKey(0),

	  iMeta(0),

	  iAccessPolicy(0)

	{

	Mem::FillZ(&iValue, sizeof(iValue));

	}

inline TServerSetting::TServerSetting(const TUint32 aKey)

	: iKey(aKey),

	  iMeta(0),

	  iAccessPolicy(0)

	{

	Mem::FillZ(&iValue, sizeof(iValue));

	}

/** Ensures this setting has the same type and value of source. Where EString types

are involved, safely removes previously-owned string, and deep copies string taken

from source.

Does not require source and destination type to match. Callers must check if important.

@return	KErrNone if successful or KErrNoMemory if no memory available for copying any string.

@post If error code is not KErrNone, object is guaranteed to be in its original state.

*/

inline TInt TServerSetting::ReplaceTypeAndValue(const TServerSetting& source)

	{

	ASSERT(IsDeleted());

	if (source.IsStr())

		{

		const HBufC8* sourceBuf = source.GetStrValue();

		HBufC8* buf = sourceBuf ? sourceBuf->Alloc() : NULL;

		if (sourceBuf && !buf)

			{

			return KErrNoMemory;

			}

		ResetValue();

		SetType(EString);

		iValue.s = buf;

		}

	else if (source.IsReal())

		{

		if(!source.iValue.r)

			{

			return KErrCorrupt;

			}

		TReal* temp = new TReal(source.GetRealValue());

		if (temp == NULL)

			{

			return KErrNoMemory;

			}

		ResetValue();

		SetType(EReal);

		iValue.r = temp;

		}

	else

		{

		ResetValue();

		SetType(source.Type());

		if (source.IsInt())

			{

			iValue.i = source.GetIntValue();

			}

		}

	return KErrNone;

	}

/** Replaces the contents of this setting with those of source, safely cleaning up previously-

owned string, and making a deep copy of source string if of string type.

Does not require source and destination type to match. Callers must check if important.

@return	KErrNone if successful or KErrNoMemory if no memory available for copying any string.

@post If error code is not KErrNone, object is guaranteed to be in its original state.

*/

inline TInt TServerSetting::Replace(const TServerSetting& aSetting)

	{

	if (aSetting.IsStr())

		{

		const HBufC8* sourceBuf = aSetting.GetStrValue();

		HBufC8* targetBuf = sourceBuf ? sourceBuf->Alloc() : NULL;

		if (sourceBuf && !targetBuf)

			{

			return KErrNoMemory;

			}

		Reset();

		*this = aSetting;

		iValue.s = targetBuf;

		}

	else if (aSetting.IsReal())

		{

		TReal* temp = new TReal(aSetting.GetRealValue());

		if(temp == NULL)

			{

			return KErrNoMemory;

			}

		Reset();

		*this = aSetting;

		iValue.r = temp;

		temp = NULL;

		}

	else

		{

		Reset();

		*this = aSetting;

		}

	return KErrNone;

	}

/** Transfer ownership of the contents of this setting with those of source, safely cleaning up previously-

owned string, and making a deep copy of source string if of string type.

Does not require source and destination type to match. Callers must check if important.

@return	KErrNone if successful or KErrNoMemory if no memory available for copying any string.

@post If error code is not KErrNone, object is guaranteed to be in its original state.

*/

inline TInt TServerSetting::Transfer(TServerSetting& aSetting)

	{

	Reset();

	*this = aSetting;

	Mem::FillZ(&aSetting.iValue, sizeof(aSetting.iValue));

	aSetting.SetType(EDeleted);

	return KErrNone;

	}

inline TUint32 TServerSetting::Key() const

	{

	return iKey;

	}

inline void TServerSetting::SetKey(TUint32 aKey)

	{

	iKey = aKey;

	}

inline TUint32 TServerSetting::Meta() const

	{

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	return iMeta & ~KMetaInternal;

#else

	return iMeta & ~KMetaType;

#endif	

	}

inline void TServerSetting::SetMeta(const TUint32 aMeta)

	{

	iMeta = (iMeta & KMetaType) | (aMeta & ~KMetaType);

	}

inline TUint32 TServerSetting::Type() const

	{

	return iMeta & KMetaType;

	}

inline void TServerSetting::SetType(const TUint32 aType)

	{

	iMeta = (iMeta & ~KMetaType) | (aType & KMetaType);

	}

inline TInt TServerSetting::GetIntValue() const

	{

	return iValue.i;

	}

inline const TReal& TServerSetting::GetRealValue() const

	{

	return *(iValue.r);

	}

inline const HBufC8* TServerSetting::GetStrValue() const

	{

	return iValue.s;

	}

inline void TServerSetting::SetIntValue(TInt aVal)

	{

	SetType(EInt);

	iValue.i = aVal;

	}

inline void TServerSetting::SetRealValue(const TReal* aVal)

	{

	ASSERT(aVal);

	SetType(EReal);

	iValue.r = const_cast<TReal*>(aVal);

	}

inline void TServerSetting::SetStrValue(const HBufC8* aVal)

	{

	SetType(EString);

	if(aVal && !aVal->Length())

		{

		delete aVal;

		iValue.s = NULL;

		}

	else

		{

		iValue.s = const_cast<HBufC8*>(aVal);

		}

	}

inline void TServerSetting::SetDeleted()

	{

	SetType(EDeleted);

	}

inline TInt TServerSetting::CopyValue(TInt aVal)

	{

	Reset();

	SetIntValue(aVal);

	return KErrNone;

	}

inline TInt TServerSetting::CopyValue(const TReal& aVal)

	{

	Reset();

	TReal* temp=new TReal(aVal);

	if (!temp)

		return KErrNoMemory;

	SetRealValue(temp);

	return KErrNone;	

	}

inline TInt TServerSetting::CopyValue(const TDesC8& aVal)

	{

	Reset();

	if (aVal.Length())

		{

		HBufC8* temp=aVal.Alloc();

		if (!temp)

			return KErrNoMemory;

		SetStrValue(temp);

		}

	else

		{

		SetStrValue(NULL);

		}

	return KErrNone;

	}

inline void TServerSetting::CopyValueL(TInt aVal)

	{

	User::LeaveIfError(CopyValue(aVal));

	}

inline void TServerSetting::CopyValueL(const TReal& aVal)

	{

	User::LeaveIfError(CopyValue(aVal));

	}

inline void TServerSetting::CopyValueL(const TDesC8& aVal)

	{

	User::LeaveIfError(CopyValue(aVal));

	}

inline TInt TServerSetting::AssignValueTo(TInt& aVal) const

	{

	return IsInt() ? (aVal=iValue.i, KErrNone) : KErrArgument;

	}

inline TInt TServerSetting::AssignValueTo(TReal& aVal) const

	{

	return IsReal() ? 

		(iValue.r ? (aVal=*(iValue.r), KErrNone) : KErrCorrupt)

		: KErrArgument;

	}

inline TInt TServerSetting::AssignValueTo(TDes8& aVal) const

	{

	return IsStr() ?

		(iValue.s ? (aVal=iValue.s->Des(), KErrNone) : (aVal=KNullDesC8, KErrNone))

		: KErrArgument;

	}

inline TInt TServerSetting::AssignValueFrom(TInt aVal)

	{

	return IsInt() ? (iValue.i=aVal, KErrNone) : KErrArgument;

	}

inline TInt TServerSetting::AssignValueFrom(const TReal& aVal)

	{

	if(!IsReal())

		{

		return KErrArgument;

		}

	TReal* temp = new TReal(aVal);

	if (!temp)

		return KErrNoMemory;

	delete iValue.r;

	iValue.r = temp;

	temp = NULL;

	return KErrNone;

	}

inline TInt TServerSetting::AssignValueFrom(const TDesC8& aVal)

	{

	if(!IsStr())

		return KErrArgument;

	if(aVal.Length())

		{

		HBufC8* buf = aVal.Alloc();

		if (!buf)

			return KErrNoMemory;

		delete iValue.s;

		iValue.s = buf;

		}

	else

		{

		delete iValue.s;

		iValue.s = NULL;

		}

	return KErrNone;

	}

inline void TServerSetting::Reset()

	{

	ResetValue();

	iAccessPolicy = NULL;

	}

inline void TServerSetting::ResetValue()

	{

	if(IsStr())

		{

		if(iValue.s)

			{

			delete iValue.s;

			}

		}

	if(IsReal())

		{

		ASSERT(iValue.r);

		delete iValue.r;

		}

	iValue.i = 0;

	}

inline void TServerSetting::PushL() const

	{

	if(IsStr() && iValue.s)

		{

		CleanupStack::PushL(iValue.s);

		}

	else if(IsReal())

		{

		CleanupStack::PushL(iValue.r);

		}

	}

inline void TServerSetting::Pop() const

	{

	if(IsStr() && iValue.s)

		{

		CleanupStack::Pop(iValue.s);

		}

	else if(IsReal())

		{

		CleanupStack::Pop(iValue.r);

		}

	}

inline void TServerSetting::PopAndDestroy() const

	{

	if(IsStr() && iValue.s)

		{

		CleanupStack::PopAndDestroy(iValue.s);

		}

	else if(IsReal())

		{

		CleanupStack::PopAndDestroy(iValue.r);

		}

	}

inline TInt TServerSetting::operator==(const TServerSetting& aSetting) const

	{

	return	aSetting.IsInt() && *this==aSetting.iValue.i ||

		aSetting.IsReal() && aSetting.iValue.r && *this==*(aSetting.iValue.r) ||

		aSetting.IsStr() && !aSetting.iValue.s && !iValue.s ||

		aSetting.IsStr() && aSetting.iValue.s && *this==aSetting.iValue.s->Des();

	}

inline TInt TServerSetting::operator==(TInt aVal) const

	{

	return IsInt() && iValue.i==aVal;

	}

inline TInt TServerSetting::operator==(const TReal& aVal) const

	{

	return IsReal() && iValue.r && *(iValue.r)==aVal;

	}

inline TInt TServerSetting::operator==(const TDesC8& aVal) const

	{

	return IsStr() && iValue.s && iValue.s->Des()==aVal;

	}

inline TSettingsAccessPolicy* TServerSetting::AccessPolicy() const

	{

	return iAccessPolicy;

	}

inline void TServerSetting::SetAccessPolicy(TSettingsAccessPolicy* aPolicy)

	{

	iAccessPolicy = aPolicy;

	}

//inline const RArray<TSecurityPolicy>& TServerSetting::GetReadAccessPolicy()

inline const TSecurityPolicy* TServerSetting::GetReadAccessPolicy() const

	{

	return iAccessPolicy ? iAccessPolicy->GetReadAccessPolicy() : NULL;

	}

//inline const RArray<TSecurityPolicy>& TServerSetting::GetWriteAccessPolicy()

inline const TSecurityPolicy* TServerSetting::GetWriteAccessPolicy() const 

	{

	return iAccessPolicy ? iAccessPolicy->GetWriteAccessPolicy() : NULL;

	}

inline TBool TServerSetting::HasAccessPolicy() const

	{

	return NULL != iAccessPolicy;

	}

inline void TServerSetting::ExternalizeMetaL(RWriteStream& aStream) const

	{

	//Historically, CRE file stores type and meta information seperately for 

	//TServerSetting. To save memory, this has been changed for the 

	//in-memory representation but we must store and retrieve the meta in the

	//same way for compatibility with existing backup and cre files.

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

	aStream << (Meta() | (iMeta & KMetaIndividual)) ;

#else	

	aStream << Meta(); 	

#endif	

	TUint32 type = Type();

	TUint8 temp = static_cast<TUint8>(type >> 28) ;

	aStream << temp ;

	}

inline void TServerSetting::ExternalizeL(RWriteStream& aStream) const

	{

	aStream << iKey ;

	ExternalizeMetaL(aStream);

	switch (Type())

		{

		case EInt:

			{

			TInt32 integerValue = iValue.i ;

			aStream << integerValue ;

			break ;

			}		

		case EReal :

			ASSERT(iValue.r);

			aStream << *(iValue.r) ;

			break ;

		case EString :

			if(iValue.s)

				{

				aStream << *(iValue.s) ;

				}

			else

				{

				aStream << KNullDesC8 ;

				}

			break ;

		case EDeleted :

			// Deleted settings should never be in a settings list being made

			// persistent. Hence, fail assert if attempting to externalize them:

			ASSERT(EFalse);

			break ;

		}	

	}

inline void TServerSetting::InternalizeMetaL(RReadStream& aStream)

	{

	//Historically, CRE file stores type and meta information seperately for 

	//TServerSetting. To save memory, this has been changed for the 

	//in-memory representation but we must store and retrieve the meta in the

	//same way for compatibility with existing backup and cre files.

	TUint32 meta;

	aStream >> meta;

	SetMeta(meta) ;

	TUint8 temp ;

	aStream >> temp ;

	TUint32 type = (static_cast<TUint32>(temp)) << 28;

	SetType(type);

	}

inline void TServerSetting::InternalizeL(RReadStream& aStream) 

{

	aStream >> iKey ;

	InternalizeMetaL(aStream);

	switch (Type())

		{

		case EInt:

			{

			TInt32 integerValue;

			aStream >> integerValue ;

			iValue.i = integerValue ;

			break ;

			}			

		case EReal:

			iValue.r = new(ELeave)TReal;

			aStream >> *(iValue.r);

			break ;

		case EString :

			{

			HBufC8* string = HBufC8::NewL (aStream, KMaxBinaryLength) ;

			if(string->Length())

				{

				iValue.s =	string;	

				}

			else

				{

				delete string;

				iValue.s = NULL;

				}

			break ;

			}

		case EDeleted :

			// Deleted settings should never be in a persistent settings list.

			// Hence, fail assert if attempting to internalize them:

			ASSERT(EFalse);

			break ;

		}	

	}

inline TBool TServerSetting::IsType(const TInt&) const

	{ 

	return Type() == EInt; 

	}

inline TBool TServerSetting::IsType(const TReal&) const

	{ 

	return Type() == EReal; 

	}

inline TBool TServerSetting::IsType(const TDesC8&) const

	{ 

	return Type() == EString; 

	}

inline TBool TServerSetting::IsType(const TDesC16&) const

	{ 

	return Type() == EString; 

	}

inline TBool TServerSetting::IsInt() const

	{

	return (iMeta & KMetaType) == EInt;

	}

inline TBool TServerSetting::IsReal() const

	{

	return (iMeta & KMetaType) == EReal;

	}

inline TBool TServerSetting::IsStr() const

	{

	return (iMeta & KMetaType) == EString;

	}

inline TBool TServerSetting::IsDeleted() const

	{

	return (iMeta & KMetaType) == EDeleted;

	}

inline TSettingsAccessPolicy::TSettingsAccessPolicy(TSecurityPolicy& aReadPolicy,

													TSecurityPolicy& aWritePolicy,

													TUint32 aLowKey, TUint32 aHighKey,

													TUint32 aKeyMask)

	{

	iLowKey = aLowKey; 

	iHighKey = aHighKey;

	iKeyMask = aKeyMask;

	iReadAccessPolicy.Set(aReadPolicy.Package());

	iWriteAccessPolicy.Set(aWritePolicy.Package());

	}

inline TSettingsAccessPolicy::TSettingsAccessPolicy(TSecurityPolicy& aReadPolicy,

													TSecurityPolicy& aWritePolicy,

													TUint32 aKey)

	{

	iLowKey = aKey; 

	iHighKey = 0;

	iKeyMask = 0;

	iReadAccessPolicy.Set(aReadPolicy.Package());

	iWriteAccessPolicy.Set(aWritePolicy.Package());

	}

inline TSettingsAccessPolicy::TSettingsAccessPolicy(TUint32 key)

	{

	iLowKey = key; 

	iHighKey = 0;

	iKeyMask = 0;

	}

inline TSettingsAccessPolicy::TSettingsAccessPolicy()

	{

	iLowKey = 0; 

	iHighKey = 0;

	iKeyMask = 0;

	}

inline TBool TSettingsAccessPolicy::IsInRange(TUint32 aKey) const

	{

	if((iLowKey<=aKey)&&(aKey<=iHighKey))

		return ETrue;

	else if((0 != iKeyMask)&&((iKeyMask&aKey)==iLowKey))

		return ETrue;

	return EFalse;

	}

inline void TSettingsAccessPolicy::ExternalizeL(RWriteStream& aStream) const

{

	aStream << iLowKey ;

	aStream << iHighKey ;

	aStream << iKeyMask ;

	// Externalize TSecurityPolicy objects as descriptors

	aStream << (iReadAccessPolicy.Package()) ;

	aStream << (iWriteAccessPolicy.Package()) ;

}

inline void TSettingsAccessPolicy::InternalizeL(RReadStream& aStream) 

{

	aStream >> iLowKey ;

	aStream >> iHighKey ;

	aStream >> iKeyMask ;

	// Internalize TSecurityPolicy objects as descriptors and then use them

	// to set the actual TSecurityPolicy member data.

	HBufC8* securityPolicyPackage ;

	securityPolicyPackage = HBufC8::NewLC(aStream, 10000);

	iReadAccessPolicy.Set(securityPolicyPackage->Des()) ;

	CleanupStack::PopAndDestroy(securityPolicyPackage) ;

	securityPolicyPackage = HBufC8::NewLC(aStream, 10000);

	iWriteAccessPolicy.Set(securityPolicyPackage->Des()) ;

	CleanupStack::PopAndDestroy(securityPolicyPackage) ;

	}

inline TUint32 TSettingsAccessPolicy::LowKey() const

	{

	return iLowKey;

	}

inline TUint32 TSettingsAccessPolicy::HighKey() const

	{

	return iHighKey;

	}

inline TUint32 TSettingsAccessPolicy::KeyMask() const

	{

	return iKeyMask;

	}

/**

@internalTechnology

It is responsility of client to check the key,

this simply returns the TSecurityPolicy - it is set to EAlwaysFail if uninitialised

*/

inline const TSecurityPolicy* TSettingsAccessPolicy::GetReadAccessPolicy() const

	{

	return &iReadAccessPolicy;

	}

/**

@internalTechnology

It is responsility of client to check the key,

this simply returns the TSecurityPolicy - it is set to EAlwaysFail if uninitialised

*/	

inline const TSecurityPolicy* TSettingsAccessPolicy::GetWriteAccessPolicy() const

	{

	return &iWriteAccessPolicy;

	}

inline TSettingsDefaultMeta::TSettingsDefaultMeta(TUint32 aValue, TUint32 aLowKey,

												  TUint32 aHighKey, TUint32 aKeyMask)

	{

	iLowKey = aLowKey; 

	iHighKey = aHighKey;

	iKeyMask = aKeyMask;

	iDefaultMetaData = aValue;

	}

inline TSettingsDefaultMeta::TSettingsDefaultMeta()

	{

	iLowKey = 0; 

	iHighKey = 0;

	iKeyMask = 0;

	iDefaultMetaData = 0;

	}

inline TUint32 TSettingsDefaultMeta::LowKey() const

	{

	return iLowKey;

	}

inline TUint32 TSettingsDefaultMeta::HighKey() const

	{

	return iHighKey;

	}

inline TUint32 TSettingsDefaultMeta::KeyMask() const

	{

	return iKeyMask;

	}

inline TBool TSettingsDefaultMeta::IsInRange(TUint32 aKey) const

	{

	if((iLowKey<=aKey)&&(aKey<=iHighKey))

		return ETrue;

	else if((0 != iKeyMask)&&((iKeyMask&aKey)==iLowKey))

		return ETrue;

	return EFalse;

	}

inline void TSettingsDefaultMeta::ExternalizeL(RWriteStream& aStream) const

	{

	aStream << iLowKey ;

	aStream << iHighKey ;

	aStream << iKeyMask ;

	aStream << iDefaultMetaData ;

	}

inline void TSettingsDefaultMeta::InternalizeL(RReadStream& aStream)

	{

	aStream >> iLowKey ;

	aStream >> iHighKey ;

	aStream >> iKeyMask ;

	aStream >> iDefaultMetaData;

	}

inline TSettingSingleMeta::TSettingSingleMeta(TUint32 aKey, TUint32 aMeta) : iKey(aKey), iMeta(aMeta)

	{

	}

#ifdef SYMBIAN_CENTREP_SUPPORT_MULTIROFS

inline void TServerSetting::SetIndividualMeta(TBool aIndividualSettingMeta)

	{

	if (aIndividualSettingMeta)

		iMeta|= KMetaIndividual;

	else

		iMeta&=~KMetaIndividual;

	}

//NEW: Copy the value only from a source, already validate the type

inline TInt TServerSetting::CopyTypeValue(const TServerSetting& source)

	{

	if (source.IsStr())

		{

		const HBufC8* sourceBuf = source.GetStrValue();

		HBufC8* buf = sourceBuf ? sourceBuf->Alloc() : NULL;

		if (sourceBuf && !buf)

			{

			return KErrNoMemory;

			}

		ResetValue();			

		SetType(EString);		

		iValue.s = buf;

		}

	else if (source.IsReal())

		{

		if(!source.iValue.r)

			{

			return KErrCorrupt;

			}

		TReal* temp = new TReal(source.GetRealValue());

		if (temp == NULL)

			{

			return KErrNoMemory;

			}

		ResetValue();	

		SetType(EReal);		

		iValue.r = temp;

		}

	else

		{

		SetType(source.Type());		

		if (source.IsInt())

			{

			iValue.i = source.GetIntValue();

			}

		}

	return KErrNone;

	}

#endif