diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/store/USTOR/UT_MAP.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/persistentdata/persistentstorage/store/USTOR/UT_MAP.CPP	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,249 @@
+// Copyright (c) 1998-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 "UT_STD.H"
+
+//#pragma message( __FILE__ " : Find helper function may be less code." )
+
+const TInt KStoreMapGranularity=4;
+
+EXPORT_C CStoreMap* CStoreMap::NewL(CStreamStore& aStore)
+/** Allocates and constructs a store map associated with the specified store and 
+returns a pointer to that store map.
+
+The function leaves if it cannot complete successfully.
+
+@param aStore A reference to the store associated with this store map.
+@return A pointer to the new store map object. */
+	{
+	return new(ELeave) CStoreMap(aStore);
+	}
+
+EXPORT_C CStoreMap* CStoreMap::NewLC(CStreamStore& aStore)
+/** Allocates and constructs a store map associated with the specified store, returns 
+a pointer to that store map and puts the pointer onto the cleanup stack.
+
+The function leaves if it cannot complete successfully.
+
+Placing a pointer to this object onto the cleanup stack allows the object 
+and allocated resources to be cleaned up if a subsequent leave occurs.
+
+@param aStore A reference to the store associated with this store map.
+@return A pointer to the new store map object. */
+	{
+	CStoreMap* map=NewL(aStore);
+	CleanupStack::PushL(map);
+	return map;
+	}
+
+EXPORT_C CStoreMap::CStoreMap(CStreamStore& aStore)
+	: iArray(KStoreMapGranularity),iFree(KNullStreamId),iStore(&aStore)
+	{}
+
+EXPORT_C CStoreMap::~CStoreMap()
+/** Frees resources owned by the object, prior to its destruction.
+
+In particular, the destructor deletes all streams whose stream ids are currently 
+held within the store map and then empties the store map. */
+	{
+	ResetAndDestroy();
+	}
+
+EXPORT_C void CStoreMap::BindL(TSwizzleC<TAny> aSwizzle,TStreamId anId)
+/** Creates an entry in the store map to contain the specified stream id and an 
+associated swizzle. On return from this function, the stream id is said to 
+be bound to the swizzle.
+
+If the store map already contains an entry with the same swizzle, then the 
+new entry replaces the existing entry; in effect, knowledge of the original 
+stream id associated with aSwizzle, is lost.
+
+Callers of this function can pass any type of swizzle as the first parameter, 
+i.e. any swizzle derived from TSwizzleCBase. The required TSwizzleC<TAny> 
+object is constructed from the swizzle passed by the caller.
+
+Note that in most applications, callers pass a general swizzle, i.e. an object 
+of type TSwizzle<class T>, where T is the type of object represented by that 
+swizzle.
+
+@param aSwizzle Any swizzle derived from TSwizzleCBase.
+@param anId The stream id to be bound to the swizzle. */
+	{
+	__ASSERT_DEBUG(aSwizzle!=NULL||anId==KNullStreamId,Panic(EStoreMapSwizzleMissing));
+	if (aSwizzle==NULL)
+		return;
+//
+	__ASSERT_DEBUG(anId!=KNullStreamId,Panic(EStoreMapIdMissing));
+	__DEBUG(TSwizzleC<TAny> label=Label(anId));
+	__ASSERT_DEBUG(label==NULL||label==aSwizzle,Panic(EStoreMapIntroducingAlias));
+	TEntry entry;
+	entry.swizzle=aSwizzle;
+	TKeyArrayFix key(_FOFF(TEntry,swizzle),ECmpTUint32);
+	TInt i;
+	if (iArray.FindIsq(entry,key,i)==0)
+		{
+		iArray[i].id=anId;
+		return;
+		}
+//
+	__ASSERT_DEBUG(iFree==KNullStreamId,Panic(EStoreMapFreeIdPresent));
+	iFree=entry.id=anId;
+	iArray.InsertL(i,entry);
+	iFree=KNullStreamId;
+	}
+
+EXPORT_C void CStoreMap::Unbind(TSwizzleC<TAny> aSwizzle)
+/** Deletes the first entry from the store map corresponding to the specified swizzle.
+
+On return from this function, the swizzle is said to be unbound and knowledge 
+of the associated stream id is lost.
+
+Callers of this function can pass any type of swizzle as the parameter, i.e. 
+any swizzle derived from TSwizzleCBase. The required TSwizzleC<TAny> object 
+is constructed from the swizzle passed by the caller.
+
+Notes:
+
+In most applications, callers pass a general swizzle, i.e. an object of type 
+TSwizzle<class T>, where T is the type of object represented by that swizzle.
+
+If no matching entry can be found in the store map, then the store map remains 
+unaltered.
+
+@param aSwizzle Any swizzle derived from TSwizzleCBase. */
+	{
+	TEntry entry;
+	entry.swizzle=aSwizzle;
+	TKeyArrayFix key(_FOFF(TEntry,swizzle),ECmpTUint32);
+	TInt i;
+	if (iArray.FindIsq(entry,key,i)==0)
+		iArray.Delete(i);
+	}
+
+EXPORT_C void CStoreMap::Forget(TStreamId anId)
+/** Deletes an entry from the store map. The entry selected is the first one whose 
+stream id matches the specified stream id.
+
+On return from this function, the stream id is said to be forgotten and knowledge 
+of that stream id is lost.
+
+@param anId The stream id used to identify the entry in the store map to be 
+deleted. */
+	{
+	if (anId==iFree)
+		{
+		iFree=KNullStreamId;
+		return;
+		}
+//
+	TEntry entry;
+	entry.id=anId;
+	TKeyArrayFix key(_FOFF(TEntry,id),ECmpTUint32);
+	TInt i;
+	if (iArray.Find(entry,key,i)==0)
+		iArray.Delete(i);
+	}
+
+EXPORT_C void CStoreMap::Reset()
+/** Deletes all entries from the store map.
+
+It is important that this function is called before deleting the store map, 
+as the destructor attempts to delete all streams whose stream ids are held 
+within the map. */
+	{
+	iFree=KNullStreamId;
+	iArray.Reset();
+	}
+
+EXPORT_C void CStoreMap::ResetAndDestroy()
+/** Deletes all streams whose ids are held within the store map, and then empties 
+the store map. */
+	{
+	iStore->Delete(iFree);
+	for (TIterator iter=Begin(),end=End();iter!=end;++iter)
+		{
+		const TEntry& entry=*iter;
+		iStore->Delete(entry.id);
+		}
+	Reset();
+	}
+
+EXPORT_C TStreamId CStoreMap::At(TSwizzleC<TAny> aSwizzle) const
+/** Returns the stream id of the first entry the store map matching the specified 
+swizzle.
+
+Callers of this function can pass any type of swizzle as the first parameter, 
+i.e. any swizzle derived from TSwizzleCBase. The required TSwizzleC<TAny> 
+object is constructed from the swizzle passed by the caller.
+
+@param aSwizzle Any type of swizzle derived from TSwizzleCBase.
+@return The required streamid.KNullStreamId, if no matching entry can be found. */
+	{
+	TEntry entry;
+	entry.swizzle=aSwizzle;
+	TKeyArrayFix key(_FOFF(TEntry,swizzle),ECmpTUint32);
+	TInt i;
+	if (iArray.FindIsq(entry,key,i)!=0)
+		return KNullStreamId;
+//
+	return iArray[i].id;
+	}
+
+EXPORT_C TSwizzleC<TAny> CStoreMap::Label(TStreamId anId) const
+/** Returns the swizzle in the store map assocated with the specified stream id.
+
+@param anId The id of the stream
+@return The associated swizzle. If there is no matching swizzle, then this 
+is an uninitialized swizzle. */
+	{
+	TEntry entry;
+	entry.id=anId;
+	TKeyArrayFix key(_FOFF(TEntry,id),ECmpTUint32);
+	TInt i;
+	if (iArray.Find(entry,key,i)!=0)
+		return NULL;
+//
+	return iArray[i].swizzle;
+	}
+
+EXPORT_C CStoreMap::TIterator CStoreMap::Begin() const
+//
+// Return the starting iterator for map iteration.
+//
+	{
+	return (iArray.Count()==0)?NULL:&iArray[0];
+	}
+
+EXPORT_C CStoreMap::TIterator CStoreMap::End() const
+//
+// Return the end iterator for map iteration.
+//
+	{
+	return Begin()+iArray.Count();
+	}
+
+void CStoreMap::ExternalizeL(const TStreamRef& aRef,RWriteStream& aStream) const
+//
+// Write the stream id bound to aRef to aStream.
+//
+	{
+	TSwizzleC<TAny> swizzle=aRef;
+	TStreamId id=At(swizzle);
+	if (id==KNullStreamId&&swizzle!=NULL)
+		__LEAVE(KErrNotFound);
+//
+	aStream<<id;
+	}
+