MCL/sf/app/contacts: comparison predictivesearch/PcsAlgorithm/Algorithm1/src/CPcsAlgorithm1.cpp

equal deleted inserted replaced

-:81f8547efd4f
+:e8e3147d53eb
 #include "CWords.h"
 #include "CPsQuery.h"
 #include "CPsDataPluginInterface.h"
 #include "CPcsDefs.h"
-const TInt KSpace = 32;
+const TText KSpace = ' ';
 // UID used for Publish and Subscribe mechanism
 // This should be same as the one defined in CPsPropertyHandler.cpp
 const TUid KCStatus = {0x2000B5B6};
 {
 	User::LeaveIfError(err);
 }
 // Initialize key map and pti engine
-//keyMap = CPcsKeyMap::NewL();
+//iKeyMap = CPcsKeyMap::NewL();
 TInt keyMapErr = KErrNone;
 TRAP( keyMapErr, iKeyMap = CPcsKeyMap::NewL());
 if ( keyMapErr != KErrNone )
 {
 PRINT ( _L("**********************************************."));
-PRINT1 ( _L("CPcsAlgorithm1::ConstructL() KeyMap construction error. The keymap crashed with error code %d."),keyMapErr );
+PRINT1( _L("CPcsAlgorithm1::ConstructL() KeyMap construction error. The keymap crashed with error code %d."),keyMapErr );
 PRINT ( _L("Please check the keypad/language for which keymap got crashed.") );
 PRINT ( _L("**********************************************."));
+User::Leave( keyMapErr ); // we can't go on without a key map; constructing cache needs it
 }
 // Initialize helpers
 iHelper = CPcsAlgorithm1Helper::NewL(this);
 iMultiSearchHelper = CPcsAlgorithm1MultiSearchHelper::NewL(this);
 PRINT ( _L("End CPcsAlgorithm1::RemoveSpacesL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::ReplaceZeroWithSpaceL
-// Replace all '0's in a search query with " "s
+// Replace all "0"s in a search query with " "s if those characters are on
+// the same key.
 // ----------------------------------------------------------------------------
 TBool  CPcsAlgorithm1::ReplaceZeroWithSpaceL(CPsQuery& aQuery)
 {
 PRINT ( _L("Enter CPcsAlgorithm1::ReplaceZeroWithSpaceL") );
 //PRINTQUERY ( _L("CPcsAlgorithm1::ReplaceZeroWithSpaceL (BEFORE): "), aQuery );
 TBool queryModified = EFalse;
-if (iKeyMap->GetSpaceAndZeroOnSameKey())
+/* In phones like E52 and E55, where the "0" and the " " characters are on
-{
+* the same key, the "0"s have to be considered as possible separators.
-/* In phones like E52 and E55, where the "0" and the " " characters are on
+*
-* the same key, then the "0"s EItut have to be considered as possible
+* In phones like N97 and E72, where the "0" and the " " characters are on
-* separators.
+* different keys, the "0"s must not be considered as possible separators.
 */
 // Skip initial "0"s, they are not replaced into spaces
 TInt skipIndex = 0;
 while ( (skipIndex < aQuery.Count()) &&
 (aQuery.GetItemAtL(skipIndex).Character().GetNumericValue() == 0) )
+{
+skipIndex++;
+}
+// Replace remaining "0"s into spaces in case they are entered with a keyboard
+// that has "0" and " " on the same key.
+for ( TInt index = skipIndex; index < aQuery.Count(); index++ )
+{
+CPsQueryItem& item = aQuery.GetItemAtL(index);
+if ( iKeyMap->GetSpaceAndZeroOnSameKey( item.Mode() ) &&
+item.Character().GetNumericValue() == 0 )
 {
-skipIndex++;
+item.SetCharacter(KSpace);
+queryModified = ETrue;
 }
-// Replace remaining EItut "0"s into spaces
-TChar space(KSpace);
-for ( TInt index = skipIndex; index < aQuery.Count(); index++ )
-{
-CPsQueryItem& item = aQuery.GetItemAtL(index);
-if ( item.Character().GetNumericValue() == 0 &&
-item.Mode() == EItut )
-{
-item.SetCharacter(space);
-queryModified = ETrue;
-}
-}
-}
-else
-{
-/* In phones like N97 and E72, where the "0" and the " " characters are on
-* a different key, then the "0" EItut does not have to be considered as a
-* possible separator.
-*/
-PRINT ( _L("CPcsAlgorithm1::ReplaceZeroWithSpaceL: \"0\" and \" \" are on different keys, not attepting to replace") );
 }
 //PRINTQUERY ( _L("CPcsAlgorithm1::ReplaceZeroWithSpaceL (AFTER): "), aQuery );
 PRINT1 ( _L("CPcsAlgorithm1::ReplaceZeroWithSpaceL: Query modified (0=not, 1=yes): %d"), queryModified );
 {
 	PRINT ( _L("Enter CPcsAlgorithm1::PerformSearchL") );
 	__LATENCY_MARK ( _L("CPcsAlgorithm1::PerformSearchL") );
-	RPointerArray<CPsQuery> query;
 	// Local arrays to hold the search results
 	RPointerArray<CPsData> tempSearchResults;
+	CleanupClosePushL( tempSearchResults );
 RPointerArray<CPsData> tempSearchResultsIni;
+CleanupClosePushL( tempSearchResultsIni );
 RPointerArray<CPsData> tempSearchResultsMod;
+CleanupClosePushL( tempSearchResultsMod );
 // ----------------------- Perform the basic search -----------------------
 	/* Even before replacing zeroes with spaces the query can have multiple words
 	 * Some phones support infact double keyboards with possibility to type a space in qwerty mode
 	 * A space in qwerty mode can even be typed disabling temporarily PCS
 		}
 	}
 	else
 	{
 		// Copy all the contents from tempSearchResults to the results stream
-		for(int i = 0; i < resultSet; i++)
+		for(TInt i = 0; i < resultSet; i++)
 		{
 			aSearchResults.Append(WriteClientDataL(*(tempSearchResults[i])));
 		}
 	}
 	// ------------------------------------------------------------------------
 // Cleanup local results array
-	tempSearchResults.Reset();    // Don't destroy
+CleanupStack::PopAndDestroy( &tempSearchResultsMod ); // Close, don't destroy
-tempSearchResultsIni.Reset(); // Don't destroy
+CleanupStack::PopAndDestroy( &tempSearchResultsIni ); // Close, don't destroy
-tempSearchResultsMod.Reset(); // Don't destroy
+CleanupStack::PopAndDestroy( &tempSearchResults );    // Close, don't destroy
 	__LATENCY_MARKEND ( _L("CPcsAlgorithm1::PerformSearchL") );
 	PRINT ( _L("End CPcsAlgorithm1::PerformSearchL") );
 }
 // CPcsAlgorithm1::DoSearchL
 // Search function helper
 // ----------------------------------------------------------------------------
 void  CPcsAlgorithm1::DoSearchL(const CPsSettings& aSettings,
 								CPsQuery& aQuery,
-								RPointerArray<CPsData>& searchResults,
+								RPointerArray<CPsData>& aSearchResults,
-								RPointerArray<CPsPattern>& searchSeqs )
+								RPointerArray<CPsPattern>& aSearchSeqs )
 {
 PRINT ( _L("Enter CPcsAlgorithm1::DoSearchL") );
 __LATENCY_MARK ( _L("CPcsAlgorithm1::DoSearchL") );
 // -(0)----------------- Check if group search is required ---------------
 RArray<TInt> contactsInGroup;
+CleanupClosePushL( contactsInGroup );
 RArray<TInt> groupIdArray;
+CleanupClosePushL( groupIdArray );
 // Create a new settings instance
 CPsSettings *tempSettings = aSettings.CloneL();
+CleanupStack::PushL( tempSettings );
 TBool isGroupSearch = IsGroupSearchL(*tempSettings, groupIdArray);
 if ( isGroupSearch )
 {
 // List of contacts in this group
 	GetContactsInGroupL ( groupIdArray[0], contactsInGroup );
 }
-	groupIdArray.Close();
 // -----------------------------------------------------------------------
 // Extract query list.
 RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);
+CleanupResetAndDestroyPushL( queryList );
 PRINTQUERYLIST ( _L("CPcsAlgorithm1::DoSearchL: "), queryList );
 // (1)-------------------- No query return all contacts -------------------
 if ( queryList.Count() == 0 )
 {
-	GetAllContentsL(*tempSettings, searchResults);
+	GetAllContentsL(*tempSettings, aSearchResults);
 	if ( isGroupSearch )
 	{
-		FilterSearchResultsForGroupsL ( contactsInGroup, searchResults );
+		FilterSearchResultsForGroupsL( contactsInGroup, aSearchResults );
 	}
 }
 // ------------------------------------------------------------------------
 // (2)-------------------- Perform a single query search ------------------
-else if ( queryList.Count() == 1 ) // single qwery
+else if ( queryList.Count() == 1 ) // single query
 {
 PRINT ( _L("CPcsAlgorithm1::DoSearchL: Query received is Single. Performing a SingleSearch") );
 iHelper->SearchSingleL(*tempSettings, *queryList[0], isGroupSearch,
-contactsInGroup, searchResults, searchSeqs);
+contactsInGroup, aSearchResults, aSearchSeqs);
 }
 // ------------------------------------------------------------------------
 // (3)-------------------- Perform a multi query search -------------------
 else // multiple query
 {
 	PRINT ( _L("CPcsAlgorithm1::DoSearchL: Query received is Multiple. Performing a MultiSearch") );
 		// Search results
 		iMultiSearchHelper->SearchMultiL(*tempSettings, queryList, isGroupSearch,
-		                                 contactsInGroup, searchResults, searchSeqs);
+		                                 contactsInGroup, aSearchResults, aSearchSeqs);
 }
 // -------------------------------------------------------------------------
 // Cleanup
-delete tempSettings;
-tempSettings = NULL;
+CleanupStack::PopAndDestroy( &queryList ); // ResetAndDestroy
+CleanupStack::PopAndDestroy( tempSettings );
-groupIdArray.Close();
+CleanupStack::PopAndDestroy( &groupIdArray ); // Close
-contactsInGroup.Close();
+CleanupStack::PopAndDestroy( &contactsInGroup ); // Close
-	queryList.ResetAndDestroy();
 	__LATENCY_MARKEND ( _L("CPcsAlgorithm1::DoSearchL") );
 	PRINT ( _L("End CPcsAlgorithm1::DoSearchL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::DoSearchInputL
 // Search function helper
 // ----------------------------------------------------------------------------
 void  CPcsAlgorithm1::DoSearchInputL(CPsQuery& aQuery,
-		                             TDesC& aData,
+		                             const TDesC& aData,
 		                             RPointerArray<TDesC>& aMatchSet,
 		                             RArray<TPsMatchLocation>& aMatchLocation )
 {
 PRINT ( _L("Enter CPcsAlgorithm1::DoSearchInputL") );
 	if(dataStoreIndex < 0) return;
 CPcsCache* cache = iPcsCache[dataStoreIndex];
-	TRAPD(err, cache->RemoveAllFromCacheL());
+	cache->RemoveAllFromCache();
-	if ( err != KErrNone )
-	{
-		SetCachingError(aDataStore, err);
-	}
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::GetCacheIndex
 // Return the cache index for a data store
 // ----------------------------------------------------------------------------
-TInt CPcsAlgorithm1::GetCacheIndex(TDesC& aDataStore)
+TInt CPcsAlgorithm1::GetCacheIndex(const TDesC& aDataStore)
 {
 for ( int i = 0; i < iPcsCache.Count(); i++ )
 {
 	CPcsCache* cache = iPcsCache[i];
 	TRAPD(err, cache = CPcsCache::NewL(aDataStore, *iKeyMap, iCacheCount));
 	if ( err != KErrNone )
 	{
 		SetCachingError(aDataStore, err);
 		return;
 	}
 	// Increment the cachecount
 	iCacheCount++;
 RArray<TInt> dataFields;
 TRAP(err, iPsDataPluginInterface->GetSupportedDataFieldsL(cache->GetURI(), dataFields));
 	if ( err != KErrNone )
 	{
 		SetCachingError(aDataStore, err);
 		return;
 	}
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::GetUriForIdL
 // Get the URI string for this internal id
 // ----------------------------------------------------------------------------
-TDesC& CPcsAlgorithm1::GetUriForIdL(TUint8 aUriId)
+const TDesC& CPcsAlgorithm1::GetUriForIdL(TUint8 aUriId)
 {
 TBool found = EFalse;
 TInt i = 0;
 for ( i = 0; i < iPcsCache.Count(); i++ )
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::FindStoreUri
 // Checks if this store exists
 // ----------------------------------------------------------------------------
-TInt CPcsAlgorithm1::FindStoreUri ( TDesC& aDataStore )
+TInt CPcsAlgorithm1::FindStoreUri ( const TDesC& aDataStore )
 {
 for ( int i = 0; i < iPcsCache.Count(); i++ )
 {
 	if ( aDataStore.CompareC(*(iPcsCache[i]->GetUri())) == 0 )
 	{
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::SetCachingError
 // Updates cachinge error
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm1::SetCachingError(TDesC& aDataStore, TInt aError)
+void CPcsAlgorithm1::SetCachingError(const TDesC& aDataStore, TInt aError)
 {
-	TBuf<KBufferMaxLen> store;
+	PRINT2 ( _L("SetCachingError::URI %S ERROR %d"), &aDataStore, aError );
-	store.Copy(aDataStore);
-	PRINT2 ( _L("SetCachingError::URI %S ERROR %d"), &store, aError );
 	iCacheError = aError;
-	RProperty::Set(KCStatus,1,iCacheError );
+	RProperty::Set( KCStatus,1,iCacheError );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::GetAllContentsL
 // Returns all the contents of a store
 {
 	__LATENCY_MARK ( _L("CPcsAlgorithm1::GetAllContentsL") );
 PRINT ( _L("Enter CPcsAlgorithm1::GetAllContentsL") );
-// Get the data stores
-RPointerArray<TDesC> aDataStores;
-aSettings.SearchUrisL(aDataStores);
 // To hold array of results from different data stores
 typedef RPointerArray<CPsData> CPSDATA_R_PTR_ARRAY;
-RPointerArray<CPSDATA_R_PTR_ARRAY> iSearchResultsArr;
+RPointerArray<CPSDATA_R_PTR_ARRAY> searchResultsArr;
+CleanupResetAndDestroyPushL( searchResultsArr );
+// TODO: Here's still a potential memory leak if a leave happens. The child
+// arrays of searchResultsArr are not Reset in that case. The CPsData objects
+// may leak as well. Handling this safely is somewhat complicated because some of
+// the CPsData objects may already be transferred to ownership of aResults array
+// at the time the leave happens, and those items must not be deleted.
+// Get the data stores
+RPointerArray<TDesC> dataStores;
+CleanupResetAndDestroyPushL( dataStores );
+aSettings.SearchUrisL(dataStores);
 // Get all contacts for each data store
-for ( int dsIndex = 0;
+for ( TInt dsIndex = 0;
-dsIndex < aDataStores.Count();
+dsIndex < dataStores.Count();
 dsIndex++ )
 {
 RPointerArray<CPsData> *temp = new (ELeave) RPointerArray<CPsData>();
-iSearchResultsArr.Append(temp);
+searchResultsArr.Append(temp);
-TInt arrayIndex = GetCacheIndex(*(aDataStores[dsIndex]));
+TInt arrayIndex = GetCacheIndex(*(dataStores[dsIndex]));
 		if ( arrayIndex < 0 ) continue;
 		CPcsCache* cache = GetCache(arrayIndex);
-cache->GetAllContentsL(*(iSearchResultsArr[dsIndex]));
+cache->GetAllContentsL(*(searchResultsArr[dsIndex]));
 }
-aDataStores.ResetAndDestroy();
+CleanupStack::PopAndDestroy( &dataStores ); // ResetAndDestroy
 // Merge the results from different data stores
-CPcsAlgorithm1Utils::FormCompleteSearchResultsL(iSearchResultsArr,
+CPcsAlgorithm1Utils::FormCompleteSearchResultsL(searchResultsArr,
 												aResults);
 // Cleanup the local arrays
-for(TInt i = 0; i < iSearchResultsArr.Count(); i++)
+for(TInt i = 0; i < searchResultsArr.Count(); i++)
 {
-	iSearchResultsArr[i]->Reset();
+	searchResultsArr[i]->Reset();
-	delete iSearchResultsArr[i];
+}
-	iSearchResultsArr[i] = NULL;
+CleanupStack::PopAndDestroy( &searchResultsArr ); // ResetAndDestroy
-}
-iSearchResultsArr.Reset();
 PRINT1 ( _L("Number of results = %d"), aResults.Count() );
 PRINT ( _L("End CPcsAlgorithm1::GetAllContentsL") );
 // Get the groupIds in the seach settings
 aSettings.GetGroupIdsL(aGroupIdArray);
 // Get the current URIs defined in settings
 RPointerArray<TDesC> searchUris;
+CleanupResetAndDestroyPushL( searchUris );
 aSettings.SearchUrisL(searchUris);
 if ( aGroupIdArray.Count() && (searchUris.Count() > aGroupIdArray.Count() ) )
 {
 	// There is an error, either there are more than one groups
 	// or the settings contain a combination of group/non-group Uris
-	searchUris.ResetAndDestroy();
 	aGroupIdArray.Close();
 	User::Leave(KErrArgument);
 }
-searchUris.ResetAndDestroy();
+CleanupStack::PopAndDestroy( &searchUris ); // ResetAndDestroy
 PRINT ( _L("End CPcsAlgorithm1::IsGroupSearchL") );
 if ( aGroupIdArray.Count() == 1 )
 return ETrue;
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::ReplaceGroupsUriL
 // Replace groups uri to contacts uri
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm1::ReplaceGroupsUriL ( CPsSettings& aSettings )
+void CPcsAlgorithm1::ReplaceGroupsUriL( CPsSettings& aSettings )
 {
 	RPointerArray<TDesC> uri;
+	CleanupResetAndDestroyPushL( uri );
 // Set contacts db uri
-	HBufC* cntdb = HBufC::NewL(KBufferMaxLen);
+	HBufC* cntdb = KVPbkDefaultCntDbURI().AllocLC();
-	cntdb->Des().Copy(KVPbkDefaultCntDbURI);
+	uri.AppendL(cntdb);
-	uri.Append(cntdb);
+	CleanupStack::Pop( cntdb ); // ownership transferred
 	aSettings.SetSearchUrisL(uri);
 	// Cleanup
-	uri.ResetAndDestroy();
+	CleanupStack::PopAndDestroy( &uri ); // ResetAndDestroy
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::FilterSearchResultsForGroupsL
 // Filters the results that belong to a group
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::GetContactsInGroupL
 // Recover contacts that belong to a group
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm1::GetContactsInGroupL ( TInt aGroupId,
+void CPcsAlgorithm1::GetContactsInGroupL( TInt aGroupId,
 RArray<TInt>& aGroupContactIds )
 {
 // Clear results array
 aGroupContactIds.Reset();
-// Groups URI
+// Cache Index for group database
-HBufC* groupURI = HBufC::NewL(50);
+TInt cacheIndex = GetCacheIndex(KVPbkDefaultGrpDbURI);
-groupURI->Des().Copy(KVPbkDefaultGrpDbURI);
-// Cache Index
-TInt cacheIndex = GetCacheIndex(*groupURI);
-// Cleanup
-delete groupURI;
-groupURI = NULL;
 // Get the groups contact ids
 	if ( cacheIndex != -1 )
 	{
 		RPointerArray<CPsData> groups;
+		CleanupClosePushL( groups );
 		// Get all groups
 		iPcsCache[cacheIndex]->GetAllContentsL(groups);
 	    // Get all contacts in group
 				groups[i]->IntDataExt(aGroupContactIds); // All contacts in group
 				break;
 			}
 		}
-		groups.Reset();
+		CleanupStack::PopAndDestroy( &groups ); // Close
 	}
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm1::GetDataOrderL
 cache->GetSortOrder(mySortOrder);
 if ( aSortOrder.Count() == mySortOrder.Count() )
 {
 TBool same = ETrue;
-for ( int i = 0; i < mySortOrder.Count(); i++ )
+for ( TInt i = 0; i < mySortOrder.Count(); i++ )
 {
 if ( mySortOrder[i] != aSortOrder[i] )
 		{
 			same = EFalse;
 			break;
 // ---------------------------------------------------------------------------------
 // Read the persisted sort order from the central repository
 // Persisted sort order is of form URI Field1 Field2 Field3 .. FieldN (space delimited)
 // ---------------------------------------------------------------------------------
-void CPcsAlgorithm1::ReadSortOrderFromCenRepL(TDesC& aURI,
+void CPcsAlgorithm1::ReadSortOrderFromCenRepL(const TDesC& aURI,
 RArray<TInt>& aSortOrder)
 {
 PRINT ( _L("Enter CPcsAlgorithm1::ReadSortOrderFromCenRepL.") );
 aSortOrder.Reset();
 		    if ( aURI.Compare(token) == 0 )
 		    {
 		        // Extract the sort order
 		        token.Set(lex.NextToken());
 				while ( token.Length() != 0 )
 				{
 				    TLex lex1(token);
 				    TInt intVal;
 				    TInt err = lex1.Val(intVal);
 					if ( KErrNone == err )
 					{
 						aSortOrder.Append(intVal);
 					}
 					// Next token
 					token.Set(lex.NextToken());
 				}
 				break;
 		    }
 	    }
 }
 delete repository;
 PRINT ( _L("End CPcsAlgorithm1::ReadSortOrderFromCenRepL.") );
 // ---------------------------------------------------------------------------------
 // Write the sort order into the central repository
 // Persisted sort order is of form URI Field1 Field2 Field3 .. FieldN (space delimited)
 // ---------------------------------------------------------------------------------
-void CPcsAlgorithm1::WriteSortOrderToCenRepL(TDesC& aURI,
+void CPcsAlgorithm1::WriteSortOrderToCenRepL(const TDesC& aURI,
 RArray<TInt>& aSortOrder)
 {
 PRINT ( _L("Enter CPcsAlgorithm1::WriteSortOrderToCenRepL.") );
-CRepository *repository = CRepository::NewL( KCRUidPSSortOrder );
+CRepository *repository = CRepository::NewLC( KCRUidPSSortOrder );
 	// Check if there an entry for this URI in cenrep
 	TBuf<KCRMaxLen> str;
 	TInt keyIndex = -1;
 		PRINT ( _L("CPcsAlgorithm1::WriteSortOrderToCenRepL. Persist limit violated.") );
 		return;
 	}
 // Persist the sort order
-	HBufC* str1 = HBufC::NewL(KCRMaxLen);
+	HBufC* str1 = HBufC::NewLC(KCRMaxLen);
 	TPtr ptr(str1->Des());
 	// Append the URI
 	ptr.Append(aURI);
 	ptr.Append(KSpace);
 	// Append the sort order fields
-	for ( int j = 0; j < aSortOrder.Count(); j++ )
+	for ( TInt j = 0; j < aSortOrder.Count(); j++ )
 	{
 		ptr.AppendNum(aSortOrder[j]);
 	    ptr.Append(KSpace);
 	}
 	// Write to persistent store
 	TInt err = repository->Set(keyIndex, ptr);
 	User::LeaveIfError(err);
-	delete str1;
+	CleanupStack::PopAndDestroy( str1 );
-delete repository;
+CleanupStack::PopAndDestroy( repository );
 PRINT ( _L("End CPcsAlgorithm1::WriteSortOrderToCenRepL.") );
 }
 // ---------------------------------------------------------------------------------
 // and storing it in CPcsCache. Refer CPcsAlgorithm1Utils::CompareDataBySortOrderL
 // to see how this is being used.
 User::LeaveIfError( Dll::SetTls(&iPcsCache) );
 // Initialize cache
 RPointerArray<TDesC> dataStores;
+CleanupClosePushL( dataStores );
 iPsDataPluginInterface->GetAllSupportedDataStoresL(dataStores);
-for ( int dIndex = 0; dIndex < dataStores.Count(); dIndex++ )
+for ( TInt dIndex = 0; dIndex < dataStores.Count(); dIndex++ )
 {
 AddDataStore(*(dataStores[dIndex]));
 }
-dataStores.Reset();
+CleanupStack::PopAndDestroy( &dataStores ); // Close
 }
 // End of file

branch	RCL_3
changeset 6	e8e3147d53eb
parent 0	e686773b3f54
child 7	b3431bff8c19