FCL/sf/os/persistentdata: comparison persistentstorage/centralrepository/cenrepcli/centralrepository.cpp

equal deleted inserted replaced

--1:000000000000
+:08ec8eefde2f
+// 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:
+//
+#include "clirep.h"
+/** Creates a CRepository object for accessing a repository.
+If there is no such repository, the function leaves with KErrNotFound.
+A pointer to the object is left on the cleanup stack.
+@param aRepositoryUid The UID of the repository to be accessed
+@return A pointer to a newly created CRepository object
+*/
+EXPORT_C CRepository* CRepository::NewLC(TUid aRepositoryUid)
+	{
+	return CClientRepository::NewLC(aRepositoryUid);
+	}
+/** Creates a CRepository object for accessing a repository.
+If there is no such repository, the function leaves with KErrNotFound.
+@param aRepositoryUid The UID of the repository to be accessed
+@return A pointer to a newly created CRepository object
+*/
+EXPORT_C CRepository* CRepository::NewL(TUid aRepositoryUid)
+	{
+	CRepository* rep = CRepository::NewLC(aRepositoryUid);
+	CleanupStack::Pop();
+	return rep;
+	}
+/** Destructor.
+*/
+EXPORT_C CRepository::~CRepository()
+	{
+	}
+/** Creates a new setting with an integer value.
+@param aKey New setting key.
+@param aValue Setting value.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrAlreadyExists if a setting with that key already exists
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions.
+	Outside transactions: on success the new setting is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Create(TUint32 aKey, TInt aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Create(aKey, aValue);
+	}
+/** Creates a new setting with a floating-point value.
+@param aKey New setting key.
+@param aValue Setting value.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrAlreadyExists if a setting with that key already exists
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions.
+	Outside transactions: on success the new setting is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Create(TUint32 aKey, const TReal& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Create(aKey, aValue);
+	}
+/** Creates a new setting with a descriptor value.
+@param aKey New setting key.
+@param aValue Setting value.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrAlreadyExists if a setting with that key already exists
+	KErrArgument if the descriptor is longer than KMaxBinaryLength,
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions.
+	Outside transactions: on success the new setting is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Create(TUint32 aKey, const TDesC8& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Create(aKey, aValue);
+	}
+/** Creates a new setting with a descriptor value.
+@param aKey New setting key.
+@param aValue Setting value.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrAlreadyExists if a setting with that key already exists
+	KErrArgument if the descriptor is longer than KMaxUnicodeStringLength,
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions.
+	Outside transactions: on success the new setting is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Create(TUint32 aKey, const TDesC16& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Create(aKey, aValue);
+	}
+/** Deletes a setting.
+@param aKey Key of setting to be deleted.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if the setting does not exist,
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions except KErrNotFound.
+	Outside transactions: on success the deletion of the setting is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy for that key in the repository
+*/
+EXPORT_C TInt CRepository::Delete(TUint32 aKey)
+	{
+	return (static_cast<CClientRepository*>(this))->Delete(aKey);
+	}
+/** Deletes all the settings that exist and match the specification:
+	(key & mask) == (partialKey & mask)
+Partial key is guaranteed to be masked before use.
+Examples of use:
+- To delete a single key.
+	Delete(key, 0xFFFFFFFF, errorKey);
+- To delete all keys from 0 to 0xFF:
+	Delete(0, 0xFFFFFF00, errorKey);
+	(digits from 0 to 0xFF would be ignored if given in the partial key)
+- To delete all keys matching 0x5B??3A?6:
+	Delete(0x5B003A06, 0xFF00FF0F, errorKey);
+@param aPartialKey
+	Contains a bit pattern that all the keys must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the keys being deleted.
+@param aErrorKey If the delete operation fails this contains the key involved in the
+	failure, or aPartialKey or KUnspecifiedKey if it could not be attributed to any key
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrNotFound if no items were found in the partial key range.
+	KErrPermissionDenied if caller fails capability check.
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions except KErrNotFound
+	Outside transactions: on success the changes are persistent, on failure the
+	repository is unmodified.
+@capability Dependent Caller must satisfy the write policies of all settings found in the
+					  partial key range.
+*/
+EXPORT_C TInt CRepository::Delete (TUint32 aPartialKey, TUint32 aMask, TUint32 &aErrorKey)
+	{
+	return (static_cast<CClientRepository*>(this))->Delete(aPartialKey, aMask, aErrorKey);
+	}
+/** Reads an integer setting.
+@param aKey Key of setting to be read.
+@param aValue Returns the value of the setting if it is an integer.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if the setting does not exist,
+	KErrArgument if the setting exists but is not an integer,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Get(TUint32 aKey, TInt& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Get(aKey, aValue);
+	}
+/** Sets an existing integer setting to a new value or creates a new setting
+with an integer value if the setting doesn't exist.
+@param aKey Key of setting to be written to.
+@param aValue Value to be written.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrArgument if the setting exists but is not an integer
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions.
+	Outside transactions: on success the new value is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Set(TUint32 aKey, TInt aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Set(aKey, aValue);
+	}
+/** Reads a floating point setting.
+@param aKey Key of setting to be read.
+@param aValue Returns the value of the setting if it is a floating point value.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if the setting does not exist,
+	KErrArgument if the setting exists but is not a floating point value,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Get(TUint32 aKey, TReal& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Get(aKey, aValue);
+	}
+/** Sets an existing floating point setting to a new value or creates a new setting
+with a floating point value if the setting doesn't exist.
+@param aKey Key of setting to be written to.
+@param aValue Value to be written.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrArgument if the setting exists but is not a floating point value
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions.
+	Outside transactions: on success the new value is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Set(TUint32 aKey, const TReal& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Set(aKey, aValue);
+	}
+/** Reads a descriptor setting.
+@param aKey Key of setting to be read.
+@param aValue Returns the value of the setting if it is a descriptor.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if the setting does not exist,
+	KErrArgument if the setting exists but is not a descriptor,
+	KErrOverflow if the descriptor is too small to receive the value in the repository,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Get(TUint32 aKey, TDes8& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Get(aKey, aValue);
+	}
+/** Reads a descriptor setting.
+@param aKey Key of setting to be read.
+@param aValue Returns the value of the setting if it is a descriptor.
+@param aActualLength Returns the actual length of the setting if it is a descriptor.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if the setting does not exist,
+	KErrArgument if the setting exists but is not a descriptor,
+	KErrOverflow if the descriptor is too small to receive the value in the repository,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Get(TUint32 aKey, TDes8& aValue, TInt& aActualLength)
+	{
+	return (static_cast<CClientRepository*>(this))->Get(aKey, aValue, aActualLength);
+	}
+/** Sets an existing descriptor setting to a new value or creates a new setting
+with a descriptor value if the setting doesn't exist.
+@param aKey Key of setting to be written to.
+@param aValue Value to be written.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrArgument if aValue is longer than KMaxBinaryLength or
+	the setting exists but is not a descriptor,
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions.
+	Outside transactions: on success the new value is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Set(TUint32 aKey, const TDesC8& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Set(aKey, aValue);
+	}
+/** Reads a descriptor setting.
+@param aKey Key of setting to be read.
+@param aValue Returns the value of the setting if it is a descriptor.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if the setting does not exist,
+	KErrArgument if the setting exists but is not a descriptor,
+	KErrOverflow if the descriptor is too small to receive the value in the repository,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Get(TUint32 aKey, TDes16& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Get(aKey, aValue);
+	}
+/** Reads a descriptor setting.
+@param aKey Key of setting to be read.
+@param aValue Returns the value of the setting if it is a descriptor.
+@param aActualLength Returns the actual length of the setting if it is a descriptor.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if the setting does not exist,
+	KErrArgument if the setting exists but is not a descriptor,
+	KErrOverflow if the descriptor is too small to receive the value in the repository,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Get(TUint32 aKey, TDes16& aValue, TInt& aActualLength)
+	{
+	return (static_cast<CClientRepository*>(this))->Get(aKey, aValue, aActualLength);
+	}
+/** Sets an existing descriptor setting to a new value or creates a new setting
+with a descriptor value if it doesn't exist.
+@param aKey Key of setting to be written to.
+@param aValue Value to be written.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrArgument if aValue is longer than KMaxUnicodeStringLength or
+	the setting exists but is not a descriptor,
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions.
+	Outside transactions: on success the new value is persistent,
+	on failure the repository is unmodified.
+@capability Dependent Caller must satisfy the write access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::Set(TUint32 aKey, const TDesC16& aValue)
+	{
+	return (static_cast<CClientRepository*>(this))->Set(aKey, aValue);
+	}
+/** Reads the metadata bound to a key
+@param aKey The key
+@param aMeta Returns the metadata value for the key
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if the setting does not exist,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read access policy of that key in the repository.
+*/
+EXPORT_C TInt CRepository::GetMeta(TUint32 aKey, TUint32& aMeta)
+	{
+	return (static_cast<CClientRepository*>(this))->GetMeta(aKey, aMeta);
+	}
+/** Moves all the settings that exist and match the specification:
+	(oldkey & mask) == (sourcePartialKey & mask)
+to new locations where
+	(newkey & mask) == (targetPartialKey & mask).
+For those keys that match the source specification, those bits in the key for
+which the corresponding mask bit is zero remain unchanged. All remaining bits
+change from (sourcePartialKey & mask) to (targetPartialKey & mask).
+Both partial keys are guaranteed to be masked before use.
+Examples of use:
+- To move a single key from oldKey to newKey.
+	Move(oldKey, newKey, 0xFFFFFFFF, errorKey);
+- To move all keys from 0 to 0xFF to be from 0x100 to 0x1FF:
+	Move(0, 0x100, 0xFFFFFF00, errorKey);
+	(digits from 0 to 0xFF would be ignored if given in the partial keys)
+- To move all keys matching 0x5B??3A?6 to 0xDC??44?F:
+	Move(0x5B003A06, 0xDC00440F, 0xFF00FF0F, errorKey);
+@param aSourcePartialKey
+	Contains a bit pattern that all the source keys which must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the keys being moved.
+@param aTargetPartialKey
+	Contains a bit pattern that all the target keys which must at least partially
+	match.
+@param aErrorKey on failure, contains the key or partial key involved in the error
+	or KUnspecifiedKey if failure could not be attributed to any key.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrNotFound if no items were found in the source range.
+	KErrPermissionDenied if caller fails capability check,
+	KErrAlreadyExists if an existing setting is using any intended target key.
+	plus other system-wide error codes.
+@post
+	Transactions fail on all error conditions except KErrNotFound.
+	Outside transactions: on success the changes are persistent, on failure the
+	repository is unmodified.
+@capability Dependent Caller must satisfy the read and write policies of all settings found in the
+					  source range, and write policies on all intended target keys.
+*/
+EXPORT_C TInt CRepository::Move (TUint32 aSourcePartialKey, TUint32 aTargetPartialKey,
+								 TUint32 aMask, TUint32 &aErrorKey)
+	{
+	return (static_cast<CClientRepository*>(this))->Move(aSourcePartialKey, aTargetPartialKey, aMask, aErrorKey);
+	}
+/** Finds all the settings that exist and match the specification given by
+aPartialKey and aMask.
+Matches occur whenever (key & mask) == (partialKey & mask).
+The partial key is guaranteed to be masked before use.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aFoundKeys All the keys found.
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrNotFound if no items were found in the source range,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+*/
+EXPORT_C TInt CRepository::FindL(TUint32 aPartialKey, TUint32 aMask,
+	RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindL(aPartialKey, aMask, aFoundKeys);
+	}
+/** Finds all the settings that contain a given integer and match the
+specification given by aPartialKey and aMask.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aValue Settings for the keys found will be integers with value aValue.
+@param aFoundKeys All the keys found.
+	For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and
+	the setting with key k is an integer aValue.
+@see FindL()
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if capability check passed but no matching items are found,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read policies of all settings found in the source range.
+*/
+EXPORT_C TInt CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask,
+	TInt aValue, RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindEqL(aPartialKey, aMask, aValue, aFoundKeys);
+	}
+/** Finds all the settings that contain a given floating point value and match
+the specification given by aPartialKey and aMask.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aValue
+	Settings for the keys found will be floating point values with value aValue.
+@param aFoundKeys All the keys found.
+	For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and
+	the setting with key k is a floating point value aValue.
+@see FindL()
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if capability check passed but no matching items are found,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read policies of all settings found in the source range.
+*/
+EXPORT_C TInt CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask,
+	const TReal& aValue, RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindEqL(aPartialKey, aMask, aValue, aFoundKeys);
+	}
+/** Finds all the settings that contain a given string value and match the
+specification given by aPartialKey and aMask.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aValue
+	Settings for the keys found will be string values with value aValue.
+@param aFoundKeys All the keys found.
+	For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and
+	the setting with key k is a string value aValue.
+@see FindL()
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if capability check passed but no matching items are found,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read policies of all settings found in the source range.
+*/
+EXPORT_C TInt CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask,
+	const TDesC8& aValue, RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindEqL(aPartialKey, aMask, aValue, aFoundKeys);
+	}
+/** Finds all the settings that contain a given string value and match the
+specification given by aPartialKey and aMask.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aValue
+	Settings for the keys found will be string values with value aValue.
+@param aFoundKeys All the keys found.
+	For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and
+	the setting with key k is a string value aValue.
+@see FindL()
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if capability check passed but no matching items are found,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read policies of all settings found in the source range.
+*/
+EXPORT_C TInt CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask,
+	const TDesC16& aValue, RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindEqL(aPartialKey, aMask, aValue, aFoundKeys);
+	}
+/** Finds all the settings that match the specification given by aPartialKey
+and aMask, but are either not integer values or do not have the given value.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aValue
+	Settings for the keys found will be settings that either contain values
+	that are not integers or integers other than aValue.
+@param aFoundKeys All the keys found.
+	For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and
+	the setting with key k is either not an integer or an integer not equal to
+	aValue.
+@see FindL()
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if capability check passed but no non-matching items are found,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read policies of all settings found in the source range.
+*/
+EXPORT_C TInt CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask,
+	TInt aValue, RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindNeqL(aPartialKey, aMask, aValue, aFoundKeys);
+	}
+/** Finds all the settings that match the specification given by aPartialKey
+and aMask, but are either not floating point values or do not have the given value.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aValue
+	Settings for the keys found will be settings that either contain values
+	that are not floating point or floating point values other than aValue.
+@param aFoundKeys All the keys found.
+	For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and
+	the setting with key k is either not a floating point value or a floating
+	point value not equal to aValue.
+@see FindL()
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if capability check passed but no non-matching items are found,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read policies of all settings found in the source range.
+*/
+EXPORT_C TInt CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask,
+	const TReal& aValue, RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindNeqL(aPartialKey, aMask, aValue, aFoundKeys);
+	}
+/** Finds all the settings that match the specification given by aPartialKey
+and aMask, but are either not string values or do not match the given string.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aValue
+	Settings for the keys found will be settings that either contain values
+	that are not strings or strings with value other than aValue.
+@param aFoundKeys All the keys found.
+	For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and
+	the setting with key k is either not a string value or a string value not
+	equal to aValue.
+@see FindL()
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if capability check passed but no non-matching items are found,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read policies of all settings found in the source range.
+*/
+EXPORT_C TInt CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask,
+	const TDesC8& aValue, RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindNeqL(aPartialKey, aMask, aValue, aFoundKeys);
+	}
+/** Finds all the settings that match the specification given by aPartialKey
+and aMask, but are either not string values or do not match the given string.
+@param aPartialKey
+	Contains a bit pattern that all the keys returned must at least partially
+	match.
+@param aMask
+	Has bits set for all the bits in aPartialKey that must match the returned
+	keys.
+@param aValue
+	Settings for the keys found will be settings that either contain values
+	that are not strings or strings with value other than aValue.
+@param aFoundKeys All the keys found.
+	For each key k in aFoundKeys, (k & aMask) == (aPartialKey & aMask) and
+	the setting with key k is either not a string value or a string value not
+	equal to aValue.
+@see FindL()
+@return
+	KErrNone if successful,
+	KErrAbort if in a transaction that has previously failed
+	KErrPermissionDenied if caller fails capability check,
+	KErrNotFound if capability check passed but no non-matching items are found,
+	plus other system-wide error codes.
+@post Transactions fail only on those "other system-wide error codes".
+@capability Dependent Caller must satisfy the read policies of all settings found in the source range.
+*/
+EXPORT_C TInt CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask,
+	const TDesC16& aValue, RArray<TUint32>& aFoundKeys)
+	{
+	return (static_cast<CClientRepository*>(this))->FindNeqL(aPartialKey, aMask, aValue, aFoundKeys);
+	}
+/** Requests a notification if the value of a given setting changes.
+Only one notification can be received per call to NotifyRequest.
+Only one notification per setting per CRepository may be active at any one
+time.
+@param aKey The key setting to be informed about.
+@param aStatus The object that will receive the notification. On a successful
+	outcome, this will contain the Uid of the changed setting.
+	If there is an existing notification on the same setting and same session, aStatus
+	will be set to KErrAlreadyExists and the return value will be KErrNone.
+@return
+	KErrNone if successful or if aStatus is set to KErrAlreadyExists.
+	KErrPermissionDenied if caller fails capability check.
+	KErrNotFound if the requested setting does not exist.
+@capability Note The caller must satisfy the relevant access policies for the repository
+*/
+EXPORT_C TInt CRepository::NotifyRequest(TUint32 aKey, TRequestStatus& aStatus)
+	{
+	return (static_cast<CClientRepository*>(this))->NotifyRequest(aKey, aStatus);
+	}
+/** Cancels a notification previously requested from the two-argument overload
+of NotifyRequest.
+@param aKey The parameter to the previous call to NotifyRequest to be cancelled.
+@return KErrNone The method always returns KErrNone.
+*/
+EXPORT_C TInt CRepository::NotifyCancel(TUint32 aKey)
+	{
+	//We deliberately ignore the return value from the server and return KErrNone because
+	//it is incorrect for a cancel function to return an error code - if there is no
+	//outstanding notification then the cancel should do nothing.
+	(void)(static_cast<CClientRepository*>(this))->NotifyCancel(aKey);
+	return KErrNone;
+	}
+/** Cancels all uncompleted notifications from this CRepository.
+@return KErrNone The method always returns KErrNone.
+*/
+EXPORT_C TInt CRepository::NotifyCancelAll()
+	{
+	//We deliberately ignore the return value from the server and return KErrNone because
+	//it is incorrect for a cancel function to return an error code - if there is no
+	//outstanding notification then the cancel should do nothing.
+	(void)(static_cast<CClientRepository*>(this))->NotifyCancelAll();
+	return KErrNone;
+	}
+/** Requests a notification if the value of a given setting changes.
+Only one notification can be received per call to NotifyRequest.
+Only one notification per setting per CRepository may be active at any one
+time.
+@param aPartialKey The partial key setting to be informed about.
+@param aMask The mask to be used with the partial key.
+@param aStatus The object that will receive the notification. On a successful
+	outcome, this will contain the Uid of the changed setting.
+	On error the error code is stored in aStatus and KErrNone is returned.
+@return
+	KErrNone The method always returns KErrNone.
+@capability Note The caller must satisfy the relevant access policies for the repository
+*/
+EXPORT_C TInt CRepository::NotifyRequest(TUint32 aPartialKey, TUint32 aMask,
+	TRequestStatus& aStatus)
+	{
+	return (static_cast<CClientRepository*>(this))
+		->NotifyRequest(aPartialKey, aMask, aStatus);
+	}
+/** Cancels a notification previously requested from the three-argument overload
+of NotifyRequest.
+@param aPartialKey The parameter to the previous call to NotifyRequest to be cancelled.
+@param aMask The mask to be used with the partial key
+@return KErrNone The method always returns KErrNone.
+*/
+EXPORT_C TInt CRepository::NotifyCancel(TUint32 aPartialKey, TUint32 aMask)
+	{
+	(void)(static_cast<CClientRepository*>(this))->NotifyCancel(aPartialKey, aMask);
+	return KErrNone;
+	}
+/** Resets the whole repository to the state of the initialization file
+originally used to set it up. Not currently supported in transactions.
+@return
+	KErrNone if successful,
+	KErrNotSupported if this client session is in a transaction
+	plus other system-wide error codes.
+@post Fails transaction if called when session is in one.
+@capability Dependent The caller must satisfy the relevant access policies for the repository
+*/
+EXPORT_C TInt CRepository::Reset()
+	{
+	return (static_cast<CClientRepository*>(this))->Reset();
+	}
+/** Resets the a setting within the repository to the state of the setting
+described by the initialization file originally used to set the repository up.
+Not currently supported in transactions.
+@param aKey Key of setting to be reset.
+@return
+	KErrNone if successful,
+	KErrNotSupported if this client session is in a transaction
+	plus other system-wide error codes.
+@post Fails transaction if called when session is in one.
+@capability Note The caller must satisfy the relevant access policies for the repository
+*/
+EXPORT_C TInt CRepository::Reset(TUint32 aKey)
+	{
+	return (static_cast<CClientRepository*>(this))->Reset(aKey);
+	}
+/** Attempts to starts a transaction in the given mode.
+Consistency and persistence of all values read and written during the transaction
+is only guaranteed after a successful return from CommitTransaction.
+@param aMode transaction mode: EConcurrentReadWriteTransaction (standard),
+	EReadTransaction or EReadWriteTransaction.
+@return KErrNone if successful - guaranteed for EConcurrentReadWriteTransaction,
+	KErrLocked for other transaction types if read or write locks held by other clients
+	prevent transaction from starting.
+@see CRepository::TTransactionMode
+@pre Must not be in a transaction.
+@post If it returns KErrNone: in a transaction; Any other error code: not in a transaction.
+@panic CENREPCLI 3 Panics client if this session is already in a transaction.
+*/
+EXPORT_C TInt CRepository::StartTransaction(TTransactionMode aMode)
+	{
+	return (static_cast<CClientRepository*>(this))->StartTransaction(aMode);
+	}
+/** Attempts to starts a transaction in the given mode asynchronously to
+allow client to avoid being blocked by server activity before starting.
+Consistency and persistence of all values read and written during the transaction
+is only guaranteed after a successful return from CommitTransaction.
+Use CancelTransaction to cancel asynchronous request.
+@param aMode transaction mode: EConcurrentReadWriteTransaction (standard),
+	EReadTransaction or EReadWriteTransaction.
+@see CRepository::TTransactionMode
+@param aStatus On completion of asynchronous request: KErrNone if successful -
+	guaranteed for EConcurrentReadWriteTransaction unless cancelled,
+	KErrLocked for other transaction types if read or write locks held by other clients
+	prevent transaction from starting.
+@pre Must not be in a transaction.
+@post If it completes with KErrNone and request not cancelled: in a transaction;
+	Any other error code or request cancelled: not in a transaction.
+@panic CENREPCLI 3 Panics client if this session is already in a transaction.
+*/
+EXPORT_C void CRepository::StartTransaction(TTransactionMode aMode, TRequestStatus& aStatus)
+	{
+	(static_cast<CClientRepository*>(this))->StartTransaction(aMode, aStatus);
+	}
+/** Commits a transaction. A successful return guarantees the consistency and
+persistence of all values read and written during the transaction.
+@return KErrNone on success, or error code giving first reason for failing.
+	If KErrLocked is returned for EConcurrentReadWriteTransaction, transaction
+	was interrupted by another client committing changes and should be repeated.
+@param aKeyInfo
+	On success: returns the number of keys whose values were modified.
+	On failure: returns the key or partial key involved in the first error, or
+	KUnspecifiedKey if failure could not be attributed to any key.
+@pre Must be in a transaction.
+@post Not in a transaction. On success, changes have been made persistent. On failure,
+	transaction changes have been rolled back.
+@panic CENREPCLI 4 Panics client if this session is not in a transaction.
+*/
+EXPORT_C TInt CRepository::CommitTransaction(TUint32& aKeyInfo)
+	{
+	return (static_cast<CClientRepository*>(this))->CommitTransaction(aKeyInfo);
+	}
+/** Commits a transaction asynchronously to allow client to avoid being blocked
+during the persist operation and other server activity. A successful return guarantees
+the consistency and persistence of all values read and written during the transaction.
+Use CancelTransaction to cancel asynchronous request.
+@param aKeyInfo
+	A descriptor to receive a TUint32 value, e.g. TTransactionKeyInfoBuf, which
+	client must ensure remains in scope for the duration of the asynchronous request.
+	On success: returns the number of keys whose values were modified.
+	On failure: returns the key or partial key involved in the first error, or
+	KUnspecifiedKey if failure could not be attributed to any key.
+@see CRepository::TTransactionKeyInfoBuf
+@param aStatus Completion status of asynchronous request:
+	On success (if not cancelled): KErrNone;
+	On failure: error code giving first reason for failing.
+	If KErrLocked is returned for EConcurrentReadWriteTransaction, transaction
+	was interrupted by another client committing changes and should be repeated.
+@pre Must be in a transaction.
+@post Cannot assume that transaction is "pending commit" as may have completed already.
+	Once request is complete, session is not in a transaction: on success, changes
+	have been made persistent; on failure, transaction changes have been rolled back.
+@panic CENREPCLI 4 Panics client if this session is not in a transaction.
+*/
+EXPORT_C void CRepository::CommitTransaction(TDes8& aKeyInfo, TRequestStatus& aStatus)
+	{
+	(static_cast<CClientRepository*>(this))->CommitTransaction(aKeyInfo, aStatus);
+	}
+/** Cancels the current transaction with rollback: discards any uncommitted changes.
+If the transaction is pending start or commit asynchronously, the request is
+completed with KErrCancel (unless it had already completed).
+@post Not in a transaction.
+*/
+EXPORT_C void CRepository::CancelTransaction()
+	{
+	(static_cast<CClientRepository*>(this))->CancelTransaction();
+	}
+/** Pushes onto the CleanupStack a TCleanupItem that calls CancelTransaction if
+activated by a Leave or PopAndDestroy. Important for releasing transaction resources
+including caches and read/write locks held over the repository.
+@post CleanupStack has another item on it which must be popped later with
+CleanupStack::Pop() or similar.
+*/
+EXPORT_C void CRepository::CleanupCancelTransactionPushL()
+	{
+	(static_cast<CClientRepository*>(this))->CleanupCancelTransactionPushL();
+	}
+/** Sets the active transaction to a failed state, releasing cache and locks but
+keeping it open. Has no effect when not in an active transaction, including when it
+has already failed or when pending asynchronous start or commit request completion.
+Use in preference to CancelTransaction whenever it is inappropriate to close the
+transaction at the time.
+@post
+	If previously in an active transaction: It is marked as failed. All uncommitted
+	changes are discarded. Transaction resources including cache and read/write locks
+	are released in the repository. All subsequent operations in the transaction fail
+	until it is closed by CancelTransaction or CommitTransaction. CommitTransaction
+	will fail and return KErrAbort.
+*/
+EXPORT_C void CRepository::FailTransaction()
+	{
+	(static_cast<CClientRepository*>(this))->FailTransaction();
+	}
+/** Pushes onto the CleanupStack a TCleanupItem that calls FailTransaction if
+activated by a Leave or PopAndDestroy.
+@post CleanupStack has another item on it which must be popped later with
+CleanupStack::Pop() or similar.
+*/
+EXPORT_C void CRepository::CleanupFailTransactionPushL()
+	{
+	(static_cast<CClientRepository*>(this))->CleanupFailTransactionPushL();
+	}