diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/centralrepository/common/inc/setting.inl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/persistentdata/persistentstorage/centralrepository/common/inc/setting.inl	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,822 @@
+// 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