sl@0: // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <e32base.h>
sl@0: #include "StringPoolImplementation.h"
sl@0: 
sl@0: const TInt KMapGranularity=20;
sl@0: 
sl@0: CStringPoolNode::~CStringPoolNode()
sl@0: 	{
sl@0: 	delete iDes;
sl@0: 	}
sl@0: 
sl@0: CStringPoolImplementation::CStringPoolImplementation() : iStringMapList(KMapGranularity, _FOFF(TStringIdMap, iSourceTableVal)), iStringMapListReverse(KMapGranularity, _FOFF(TStringIdMap, iTargetTableVal))
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: CStringPoolImplementation::~CStringPoolImplementation()
sl@0: 	{
sl@0: 	// Look for non-expirable strings
sl@0: 	TInt i;
sl@0: 	for (i = 0; i < KHashModulo; i++ )
sl@0: 		{
sl@0: 		DeleteUndeletableStrings(iCIHashTable, i);
sl@0: 		DeleteUndeletableStrings(iCSHashTable, i);		
sl@0: 		}
sl@0: #ifdef _DEBUG
sl@0: 
sl@0: 	__LOG(_L8(":Closing String Pool.\n"))
sl@0: 		TBool leaksFound = EFalse;
sl@0: 	// Check that the string pool is empty, or more accurately that
sl@0: 	// everything in it is a pre-loaded string
sl@0: 	for (i = 0; i < KHashModulo; i++ )
sl@0: 		{
sl@0: 		if (iCIHashTable[i])
sl@0: 			{
sl@0: 			for (TInt j = 0; j < iCIHashTable[i]->Count(); j++)
sl@0: 				{
sl@0: 				if (!StringUtils::IsTableEntry(iCIHashTable[i]->At(j).iVal))
sl@0: 					{
sl@0: 					if (!leaksFound)
sl@0: 						{
sl@0: 						__LOG(_L8("The following strings were leaked through not being Closed:\n"))
sl@0: 						leaksFound = ETrue;
sl@0: 						}
sl@0: 
sl@0: 					// Get the problem string
sl@0: 					CStringPoolNode* theProblem = 
sl@0: 						reinterpret_cast<CStringPoolNode*>(
sl@0: 							iCIHashTable[i]->At(j).iVal & KTokenToNode);
sl@0: 					if(theProblem->iDes)
sl@0: 					    __LOG(theProblem->iDes->Des());
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		if (iCSHashTable[i])
sl@0: 			{
sl@0: 			for (TInt j = 0; j < iCSHashTable[i]->Count(); j++)
sl@0: 				{
sl@0: 				if (!StringUtils::IsTableEntry(iCSHashTable[i]->At(j).iVal))
sl@0: 					{
sl@0: 					if (!leaksFound)
sl@0: 						{
sl@0: 						__LOG(_L8("The following strings were leaked through not being Closed:\n"))
sl@0: 						leaksFound = ETrue;
sl@0: 						}
sl@0: 
sl@0: 					// Get the problem string
sl@0: 					CStringPoolNode* theProblem = 
sl@0: 						reinterpret_cast<CStringPoolNode*>(
sl@0: 							iCSHashTable[i]->At(j).iVal & KTokenToNode);
sl@0: 					if(theProblem->iDes)
sl@0: 					    __LOG(theProblem->iDes->Des());
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		if (leaksFound)
sl@0: 			__DEBUGGER();
sl@0: 		}
sl@0: 
sl@0: 	if (!leaksFound)
sl@0: 		__LOG(_L8("No leakages were detected\n"));
sl@0: 
sl@0: #endif //_DEBUG
sl@0: 	for (TInt ii = 0; ii < KHashModulo; ii++)
sl@0: 		{
sl@0: 		delete iCIHashTable[ii];
sl@0: 		delete iCSHashTable[ii];
sl@0: 		}
sl@0: 		
sl@0: 	iTablePtrs.Close();
sl@0: 	iStringMapList.Close();
sl@0: 	iStringMapListReverse.Close();
sl@0: 	iRollbackMapList.Close();	
sl@0: 	iRollbackHashListCS.Close();
sl@0: 	iRollbackHashListCI.Close();
sl@0: 	// Notify the external users of the StringPool that the object is getting closed
sl@0: 	TInt cBCounter = iCallBacks.Count();
sl@0: 	if(cBCounter>0)
sl@0: 		{
sl@0: 		while (--cBCounter>=0)
sl@0: 			{
sl@0: 			iCallBacks[cBCounter]->StringPoolClosing();
sl@0: 			}
sl@0: 		}
sl@0: 	iCallBacks.Close();
sl@0: 	}
sl@0: 
sl@0: // Check for any undeletable string and delete them now
sl@0: void CStringPoolImplementation::DeleteUndeletableStrings(CArrayFixSeg<RStringTokenEither>* aArray[KHashModulo], TInt i)
sl@0: 	{
sl@0: 	if (aArray[i])
sl@0: 		{
sl@0: 		for (TInt j = 0; j < aArray[i]->Count(); ++j)
sl@0: 			{
sl@0: 			if (!StringUtils::IsTableEntry(aArray[i]->At(j).iVal))
sl@0: 				{
sl@0: 				CStringPoolNode* node= reinterpret_cast<CStringPoolNode*>(aArray[i]->At(j).iVal & KTokenToNode);
sl@0: 				if (KMarkedForNoDeleted==node->iRefcount)
sl@0: 					{
sl@0: 					delete node;										
sl@0: 					aArray[i]->Delete(j);
sl@0: 					j--;
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}	
sl@0: 	}
sl@0: 
sl@0: CStringPoolImplementation* CStringPoolImplementation::NewL()
sl@0: 	{
sl@0: 	CStringPoolImplementation* table = new (ELeave) CStringPoolImplementation();	
sl@0: 	return table;
sl@0: 	}
sl@0: 
sl@0: void CStringPoolImplementation::CleanupHashCS(TAny* aImplementation)
sl@0: 	{
sl@0: 	CStringPoolImplementation* imp=reinterpret_cast<CStringPoolImplementation*>(aImplementation);
sl@0: 	CleanUpHash(&imp->iRollbackHashListCS, imp->iCSHashTable);
sl@0: 	}
sl@0: 
sl@0: void CStringPoolImplementation::CleanupHashCI(TAny* aImplementation)
sl@0: 	{
sl@0: 	CStringPoolImplementation* imp=reinterpret_cast<CStringPoolImplementation*>(aImplementation);
sl@0: 	CleanUpHash(&imp->iRollbackHashListCI, imp->iCIHashTable);
sl@0: 	}
sl@0: 
sl@0: void CStringPoolImplementation::CleanUpHash(RPointerArray <RStringTokenEither>* aHashCleanup, CArrayFixSeg<RStringTokenEither>* aHash[KHashModulo])
sl@0: 	{
sl@0: 	if (aHashCleanup->Count()>0)
sl@0: 		{
sl@0: 		RStringTokenEither* token=(*aHashCleanup)[0];	// Get first entry
sl@0: 		for (TInt i = 0; i < KHashModulo; i++ )
sl@0: 			{
sl@0: 			if (aHash[i])
sl@0: 				{
sl@0: 				for (TInt j = 0; j < aHash[i]->Count(); j++)
sl@0: 					{
sl@0: 					if (!StringUtils::IsTableEntry(aHash[i]->At(j).iVal))
sl@0: 						{						
sl@0: 						if (aHash[i]->At(j).iVal==token->iVal)
sl@0: 							{		
sl@0: 							CStringPoolNode* node= reinterpret_cast<CStringPoolNode*>(aHash[i]->At(j).iVal & KTokenToNode);
sl@0: 							delete node;
sl@0: 							aHash[i]->Delete(j);
sl@0: 							aHashCleanup->Remove(0);
sl@0: 							break;
sl@0: 							}
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CStringPoolImplementation::CleanupIdMap(TAny* aImplementation)
sl@0: 	{
sl@0: 	CStringPoolImplementation* imp=reinterpret_cast<CStringPoolImplementation*>(aImplementation);
sl@0: 	if (imp->iRollbackMapList.Count()>0)
sl@0: 		{
sl@0: 		TStringIdMap* map=imp->iRollbackMapList[0];			
sl@0: 		TInt index=imp->iStringMapList.FindInUnsignedKeyOrder(*map);
sl@0: 		imp->iRollbackMapList.Remove(0);
sl@0: 		if (index!=KErrNotFound)
sl@0: 			{
sl@0: 			imp->iStringMapList.Remove(index);			
sl@0: 			}		
sl@0: 		index=imp->iStringMapListReverse.FindInUnsignedKeyOrder(*map);
sl@0: 		if (index!=KErrNotFound)
sl@0: 			{
sl@0: 			for (TInt count=index;count<imp->iStringMapListReverse.Count();++count)
sl@0: 				{
sl@0: 				if (imp->iStringMapListReverse[count].iTargetTableVal==map->iTargetTableVal && imp->iStringMapListReverse[count].iSourceTableVal==map->iSourceTableVal)
sl@0: 					{				
sl@0: 					imp->iStringMapListReverse.Remove(index);
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CStringPoolImplementation::AddTableL(const TStringTable& aTable)
sl@0: 	{
sl@0: 	for (TInt count=0;count<iTablePtrs.Count();++count)	// check for adding the same table twice
sl@0: 		{
sl@0: 		if (iTablePtrs[count]==&aTable)
sl@0: 			{
sl@0: 			return;
sl@0: 			}
sl@0: 		}
sl@0: 	User::LeaveIfError(iTablePtrs.Append(&aTable));	// Add the pointer to this table so we can keep track of the Table IDs. The table ID is the index in this array
sl@0: 	//Is the table Case Sensitive or not?
sl@0: 	TBool (*genericValFromIndex)(TInt, TUint16);
sl@0: 	if (aTable.iCaseSensitive==1)
sl@0: 		genericValFromIndex = StringUtils::ValFromIndex;
sl@0: 	else
sl@0: 		genericValFromIndex = StringUtils::ValFromIndexF;
sl@0: 
sl@0: 	CArrayFixSeg<RStringTokenEither>** hashTableToUse =
sl@0: 	aTable.iCaseSensitive ? iCSHashTable :iCIHashTable ;	
sl@0: 	TInt cleanupCounter=0;
sl@0: 	for (TUint i = 0; i < aTable.iCount; ++i)
sl@0: 		{
sl@0: 		const TStLitC8<1>* string=reinterpret_cast<const TStLitC8<1>* >(aTable.iTable[i]);		
sl@0: 		
sl@0: 		// Try to find the string in memory, maybe as a dynamic string or as a member of an another table  
sl@0: 		RStringTokenEither token=FindDes(*string, !aTable.iCaseSensitive);
sl@0: 		if (!token.IsNull())
sl@0: 			{
sl@0: 			TStringIdMap map;			
sl@0: 			map.iSourceTableVal=StringUtils::ValFromIndex(i, (TInt16)(iTablePtrs.Count()-1),aTable.iCaseSensitive);
sl@0: 			map.iTargetTableVal=token.iVal;
sl@0: 
sl@0: 			// Put on cleanup stack
sl@0: 			User::LeaveIfError(iRollbackMapList.Append(&map));
sl@0: 			TCleanupItem cleanup(CleanupIdMap, this);
sl@0: 			CleanupStack::PushL(cleanup);
sl@0: 			++cleanupCounter;
sl@0: 			
sl@0: 			User::LeaveIfError(iStringMapList.InsertInUnsignedKeyOrder(map));
sl@0: 
sl@0: 			// Check if this is a link to a dynamic string
sl@0: 			if (!StringUtils::IsTableEntry(token.iVal))
sl@0: 				{
sl@0: 				CStringPoolNode* node = StringUtils::NodePtr(token.iVal);
sl@0: 				node->iRefcount=KMarkedForNoDeleted; // Make sure this string never gets deleted
sl@0: 				}
sl@0: 
sl@0: 			// Now store the reverse array						
sl@0: 			User::LeaveIfError(iStringMapListReverse.InsertInUnsignedKeyOrderAllowRepeats(map));
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TUint8 hash = static_cast<TUint8>(Hash(*string));
sl@0: 			CArrayFixSeg<RStringTokenEither>* collisionList = hashTableToUse[hash];
sl@0: 			if ( !collisionList )
sl@0: 				//HashTableToUse now is used as list of all entry with the same hash
sl@0: 				collisionList = hashTableToUse[hash] = 
sl@0: 				new (ELeave) CArrayFixSeg<RStringTokenEither>( 2 );
sl@0: 			RStringTokenEither s;
sl@0: 			s.iVal = genericValFromIndex(i, (TInt16)(iTablePtrs.Count()-1));
sl@0: 			
sl@0: 			__LOG2(_L8("Table entry being added with hash %d, val %d"), hash, s.iVal);
sl@0: 			__LOG(*reinterpret_cast<const TStLitC8<1>* >(aTable.iTable[i]));
sl@0: 			// Put on cleanup stack
sl@0: 			if (aTable.iCaseSensitive==1)
sl@0: 				{
sl@0: 				User::LeaveIfError(iRollbackHashListCS.Append(&s));
sl@0: 				TCleanupItem cleanup(CleanupHashCS, this);
sl@0: 				CleanupStack::PushL(cleanup);
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				User::LeaveIfError(iRollbackHashListCI.Append(&s));
sl@0: 				TCleanupItem cleanup(CleanupHashCI, this);
sl@0: 				CleanupStack::PushL(cleanup);
sl@0: 				}
sl@0: 			
sl@0: 			++cleanupCounter;
sl@0: 			collisionList->AppendL(s);
sl@0: 			}
sl@0: 		}	
sl@0: 	CleanupStack::Pop(cleanupCounter);
sl@0: 	iRollbackMapList.Reset();
sl@0: 	iRollbackHashListCS.Reset();
sl@0: 	iRollbackHashListCI.Reset();
sl@0: 	}
sl@0: 
sl@0: // Find FirstVal given duplicate val
sl@0: TInt32 CStringPoolImplementation::FindFirstValFromDuplicate(TInt32 aDuplicateVal) const 
sl@0: 	{
sl@0: 	TStringIdMap map;
sl@0: 	map.iSourceTableVal=aDuplicateVal;	
sl@0: 	TInt index=iStringMapList.FindInUnsignedKeyOrder(map);
sl@0: 	if (index!=KErrNotFound)		
sl@0: 		return iStringMapList[index].iTargetTableVal;
sl@0: 	else
sl@0: 		return KErrNotFound;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: // Find table index Val given first val & table UID
sl@0: TInt CStringPoolImplementation::FindTableIndexFromFirstVal(TInt32 aFirstVal, TInt aTableUid) const
sl@0: 	{
sl@0: 	TStringIdMap map;
sl@0: 	map.iTargetTableVal=aFirstVal;		
sl@0: 	TInt index=iStringMapListReverse.FindInUnsignedKeyOrder(map);
sl@0: 	if (KErrNotFound==index)
sl@0: 		return KErrNotFound;
sl@0: 
sl@0: 	for (TInt count=index;count<iStringMapListReverse.Count();++count)
sl@0: 		{
sl@0: 		if (iStringMapListReverse[count].iTargetTableVal==aFirstVal && StringUtils::TableUid(iStringMapListReverse[count].iSourceTableVal)==aTableUid)
sl@0: 			{
sl@0: 			return StringUtils::TableIndex(iStringMapListReverse[count].iSourceTableVal);
sl@0: 			}
sl@0: 		}	
sl@0: 		return KErrNotFound;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: // Find the UId for a given table
sl@0: TInt16 CStringPoolImplementation::TableUid(const TStringTable& aTable) const
sl@0: 	{
sl@0: 	for (TInt count=0; count<iTablePtrs.Count(); ++count)
sl@0: 		{
sl@0: 		if (iTablePtrs[count]==&aTable)
sl@0: 			return (TInt16)count;
sl@0: 		}
sl@0: 	return KErrNotFound;
sl@0: 	}
sl@0: 
sl@0: // Find a reference to the table that first added the  string represented by aVal to the pool 
sl@0: const TStringTable& CStringPoolImplementation::TableRef(TInt32 aVal) const
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aVal!=0, StringPoolPanic::Panic(StringPoolPanic::EIllegalUseOfNullString));
sl@0: 	TInt16 tableUid=(TInt16)(aVal>>20);
sl@0: 	const TStringTable* theTableRef=(iTablePtrs[tableUid]);
sl@0: 	return  *theTableRef;
sl@0: 	}
sl@0: 
sl@0: // Find the descriptor for a given table and index
sl@0: const TDesC8& CStringPoolImplementation::TableLookup(TInt aIndex, TInt aTableUid) const
sl@0: 	{	
sl@0: 	return *reinterpret_cast<const TStLitC8<1>*>(iTablePtrs[aTableUid]->iTable[aIndex]);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: // Lookup with allocating
sl@0: //
sl@0: RStringTokenEither 
sl@0: CStringPoolImplementation::OpenL( const TDesC8& aAttributeName,
sl@0: 								  TBool aCaseInsensitive)
sl@0: 	{
sl@0: 	// lookup the attribute
sl@0: 	RStringTokenEither s(FindDes( aAttributeName , aCaseInsensitive));
sl@0: 	if (!s.IsNull())
sl@0: 		{
sl@0: 		if (!StringUtils::IsTableEntry(s.iVal))
sl@0: 			{
sl@0: 
sl@0: 			CStringPoolNode* node = StringUtils::NodePtr(s.iVal);
sl@0: 			if (KMarkedForNoDeleted!=node->iRefcount)
sl@0: 				node->iRefcount++;
sl@0: 			__LOG1(_L8("String copied (during open). Count is now %d"), node->iRefcount);
sl@0: 			__LOG(*node->iDes);
sl@0: 			}
sl@0: 		return s;
sl@0: 		}
sl@0: 	
sl@0: 	// create a new node at the end of the appropriate array
sl@0: 	CStringPoolNode* newnode = new (ELeave) CStringPoolNode();
sl@0: 	CleanupStack::PushL( newnode );
sl@0: 	newnode->iDes = aAttributeName.AllocL();
sl@0: 	newnode->iRefcount = 1;
sl@0: 
sl@0: 	TInt hash = Hash( aAttributeName );
sl@0: 	CArrayFixSeg<RStringTokenEither>** hashTableToUse = 
sl@0: 		aCaseInsensitive ? iCIHashTable : iCSHashTable;
sl@0: 	__LOG2(_L8("Newly added with hash value %d, node val 0x%x\n"), hash, newnode)
sl@0: 	__LOG(aAttributeName);
sl@0: 
sl@0: 	newnode->iHash = static_cast<TUint8>(hash);
sl@0: 	CArrayFixSeg<RStringTokenEither>* collisionList = hashTableToUse[hash];
sl@0: 	if ( !collisionList )
sl@0: 		collisionList = hashTableToUse[hash] = new (ELeave) CArrayFixSeg<RStringTokenEither>( 2 );
sl@0: 
sl@0: 	s.iVal = reinterpret_cast<TUint32>(newnode);
sl@0: 	if (aCaseInsensitive)
sl@0: 		s.iVal += 2;
sl@0: 	collisionList->AppendL(s);
sl@0: 
sl@0: 	CleanupStack::Pop(); // newnode
sl@0: 
sl@0: 	return s;
sl@0: 	}
sl@0: 
sl@0: void CStringPoolImplementation::Close(RStringTokenEither aString)
sl@0: 	{
sl@0: 	if (StringUtils::IsTableEntry(aString.iVal))
sl@0: 		return;
sl@0: 
sl@0: 	CStringPoolNode* node = StringUtils::NodePtr(aString.iVal);
sl@0: 	if (KMarkedForNoDeleted == node->iRefcount)	// -1 means a non-expirable string
sl@0: 		return;
sl@0: 	if (--node->iRefcount == 0)
sl@0: 		{
sl@0: 		//this is  the last reference of this string
sl@0: 		CArrayFixSeg<RStringTokenEither>** hashTableToUse = 
sl@0: 		aString.iVal & 2 ? iCIHashTable : iCSHashTable;
sl@0: 
sl@0: 		// Delete the node and delete the entry in the relevant collision list 
sl@0: 		CArrayFixSeg<RStringTokenEither>* collisionList = hashTableToUse[node->iHash];
sl@0: 		TInt count = collisionList->Count();		
sl@0: 		for (TInt i = 0; i < count; i++)
sl@0: 			{
sl@0: 			if (collisionList->At(i) == aString)
sl@0: 				{
sl@0: 				// Log the fact that a string reference is about to die...
sl@0: 				__LOG1(_L8("Removing string with hash value %d\n"), node->iHash)
sl@0: 				__LOG(node->iDes->Des());
sl@0: 				collisionList->Delete(i);
sl@0: 				break;
sl@0: 				}
sl@0: 			}
sl@0: 		delete node;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		__LOG1(_L8("String closed. Count is now %d"), 
sl@0: 			   node->iRefcount);
sl@0: 		__LOG(node->iDes->Des());
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: void CStringPoolImplementation::IncrementCount(RStringTokenEither aString)
sl@0: 	{
sl@0: 	if (StringUtils::IsTableEntry(aString.iVal))
sl@0: 		return;
sl@0: 	CStringPoolNode* node = StringUtils::NodePtr(aString.iVal);
sl@0: 	if (KMarkedForNoDeleted!=node->iRefcount)
sl@0: 		node->iRefcount++;
sl@0: 	__LOG1(_L8("String copied. Count is now %d"), node->iRefcount);
sl@0: 	__LOG(*node->iDes);
sl@0: 	}
sl@0: 
sl@0: // Very simple case-sensitive comparison. We can assume that the
sl@0: // strings are the same length, and we only care if the strings are
sl@0: // the same. (Unlike normal comparison functions that also tell you
sl@0: // which one is 'smaller')
sl@0: TBool CStringPoolImplementation::CompareCS(const TDesC8& s1, const TDesC8& s2)
sl@0: 	{
sl@0: 	const TUint8* ptr1 = s1.Ptr();
sl@0: 	const TUint8* ptr2 = s2.Ptr();
sl@0: 	const TUint8* stop = &ptr1[s1.Length()];
sl@0: 	for (; ptr1 < stop; ptr1++,ptr2++)
sl@0: 		{
sl@0: 		if (*ptr1 != *ptr2)
sl@0: 			return EFalse;
sl@0: 		}
sl@0: 	return ETrue;
sl@0: 	}
sl@0: 
sl@0: // Note that the hash function must generate the same hash values for
sl@0: // strings that differ by case. If changing the algorithm here make
sl@0: // sure this is still true.
sl@0: TBool CStringPoolImplementation::CompareCI(const TDesC8& s1, const TDesC8& s2)
sl@0: 	{
sl@0: 	const TUint8* ptr1 = s1.Ptr();
sl@0: 	const TUint8* ptr2 = s2.Ptr();
sl@0: 	const TUint8* stop = &ptr1[s1.Length()];
sl@0: 	for (; ptr1 < stop; ptr1++,ptr2++)
sl@0: 		{
sl@0: 		if (*ptr1 != *ptr2)
sl@0: 			{
sl@0: 			// They're not exactly the same; see if they differ only
sl@0: 			// by case. If one character is a letter, we can do a
sl@0: 			// comparison ignoring bit 5 in both cases. If that
sl@0: 			// matches, they are the same.
sl@0: 			if (!((*ptr1 & KCaseInsensitive) == (*ptr2 & KCaseInsensitive) &&
sl@0: 				  (*ptr1 >= 'A' && *ptr1 <= 'Z' || 
sl@0: 				   *ptr1 >= 'a' && *ptr1 <= 'z')))
sl@0: 				return EFalse;
sl@0: 			}
sl@0: 		}
sl@0: 	return ETrue;
sl@0: 	}
sl@0: 
sl@0: // Find the given descriptor in the hash table
sl@0: //
sl@0: RStringTokenEither 
sl@0: CStringPoolImplementation::FindDes( const TDesC8& aAttributeName, TBool aCaseInsensitive) 
sl@0: 	{
sl@0: 	CArrayFixSeg<RStringTokenEither>** hashTableToUse = 
sl@0: 		aCaseInsensitive ? iCIHashTable : iCSHashTable;
sl@0: 	CArrayFixSeg<RStringTokenEither>* collisionList =hashTableToUse[Hash(aAttributeName)];
sl@0: 	RStringPool pool;
sl@0: 	TBool (*compareFunction)(const TDesC8&, const TDesC8&);
sl@0: 	if (aCaseInsensitive)
sl@0: 		compareFunction = CompareCI;
sl@0: 	else
sl@0: 		compareFunction = CompareCS;
sl@0: 	pool.iImplementation = this;
sl@0: 	if ( collisionList )
sl@0: 		{
sl@0: 		TInt length=aAttributeName.Length();
sl@0: 		TInt count = collisionList->Count();
sl@0: 		for ( TInt i = 0; i < count; i++ )
sl@0: 			{
sl@0: 			RStringTokenEither token = collisionList->At(i);
sl@0: 			RStringEither s(this, token);
sl@0: 			const TDesC8& string = s.DesC();
sl@0: 			if ( string.Length()==length && 
sl@0: 				 (*compareFunction)(aAttributeName, string))
sl@0: 				return token;
sl@0: 			}
sl@0: 		}
sl@0: 	return RStringTokenEither();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: // Generate a hash value
sl@0: //
sl@0: TUint CStringPoolImplementation::Hash( const TDesC8& aDes ) const
sl@0: 	{
sl@0: 	// We ignore bit 5, which is a crude way of making the hash case
sl@0: 	// insensitive. This means that things that might differ only by
sl@0: 	// case end up in the same bucket, and we can then worry about
sl@0: 	// whether they're really the same later.
sl@0: 	TInt len=aDes.Length();
sl@0: 	TUint hash = 0;
sl@0: 	const TUint8* ptr=aDes.Ptr();
sl@0: 	for ( TInt i = 0; i < len; i++ )
sl@0: 		hash = 131*hash + (*ptr++ & KCaseInsensitive);
sl@0: 	return hash % KHashModulo;
sl@0: 	}
sl@0: 
sl@0: TInt StringUtils::ValFromIndex(TInt aIndex, TUint16 aTableId)
sl@0: 	{
sl@0: 	return (aTableId << 20) + (aIndex << 2) + 1;
sl@0: 	}
sl@0: 
sl@0: TInt StringUtils::ValFromIndexF(TInt aIndex, TUint16 aTableId)
sl@0: 	{
sl@0: 	return (aTableId << 20) + (aIndex << 2) + 3;
sl@0: 	}
sl@0: 
sl@0: TInt StringUtils::ValFromIndex(TInt aIndex, TUint16 aTableId, TBool aCaseSensitive)
sl@0: 	{
sl@0: 	if (aCaseSensitive)
sl@0: 		return ValFromIndex(aIndex, aTableId);
sl@0: 	else
sl@0: 		return ValFromIndexF(aIndex, aTableId);
sl@0: 	}
sl@0: void  CStringPoolImplementation::AddCallBackL( MStringPoolCloseCallBack& aCallBack)
sl@0: 	{
sl@0: 	User::LeaveIfError(iCallBacks.Append(&aCallBack));
sl@0: 	}