--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/bookmarksupport/test/cenrepsrv/setting.inl Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,724 @@
+// 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
+ {
+ return iMeta & ~KMetaType;
+ }
+
+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 void TServerSetting::CopyValueL(TInt aVal)
+ {
+ Reset();
+ SetIntValue(aVal);
+ }
+
+inline void TServerSetting::CopyValueL(const TReal& aVal)
+ {
+ Reset();
+ TReal* temp = new(ELeave)TReal(aVal);
+ SetRealValue(temp);
+ temp = NULL;
+ }
+
+inline void TServerSetting::CopyValueL(const TDesC8& aVal)
+ {
+ Reset();
+ if(aVal.Length())
+ {
+ SetStrValue(aVal.AllocL());
+ }
+ else
+ {
+ SetStrValue(NULL);
+ }
+ }
+
+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::AssignValueFromL(TInt aVal)
+ {
+ return IsInt() ? (iValue.i=aVal, KErrNone) : KErrArgument;
+ }
+
+inline TInt TServerSetting::AssignValueFromL(const TReal& aVal)
+ {
+ if(!IsReal())
+ {
+ return KErrArgument;
+ }
+ TReal* temp = new(ELeave)TReal(aVal);
+ delete iValue.r;
+ iValue.r = temp;
+ temp = NULL;
+
+ return KErrNone;
+ }
+
+inline TInt TServerSetting::AssignValueFromL(const TDesC8& aVal)
+ {
+ if(!IsStr())
+ return KErrArgument;
+
+ if(aVal.Length())
+ {
+ HBufC8* buf = aVal.AllocL();
+ 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 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.
+ aStream << Meta();
+ 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;
+}