sl@0: // Copyright (c) 2004-2010 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: // RSqlMap template class implementation.
sl@0: // ////////////////////                 TSqlPair implementation              //////////////////////////////////
sl@0: // 
sl@0: //
sl@0: 
sl@0: /**
sl@0:  
sl@0:  Initializes TSqlPair data members using the supplied parameter values.
sl@0:  
sl@0:  @param aKey Key part of TSqlPair object
sl@0:  @param aData Data part of TSqlPair object
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR> 
sl@0: TSqlPair<KEY, DATA, REFCNTR>::TSqlPair(const KEY& aKey, const DATA& aData) :
sl@0: 	iKey(aKey),
sl@0: 	iData(aData)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Initializes TSqlPair data members using the supplied parameter value.
sl@0: 
sl@0: @param aKey Key part of TSqlPair object
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR> 
sl@0: TSqlPair<KEY, DATA, REFCNTR>::TSqlPair(const KEY& aKey) :
sl@0: 	iKey(aKey)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Initializes TSqlPair data members with their default values.
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR> 
sl@0: TSqlPair<KEY, DATA, REFCNTR>::TSqlPair()
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////                 RSqlMap implementation              ///////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: @param aOrder An object of TLinearOrder< TSqlPair<KEY, DATA, REFCNTR> > type, which will be used when
sl@0: new elements are inserted into the collection (to determine their order).
sl@0: @param aDestructor An object of TSqlPairDestructor<KEY, DATA> type which will be used for the destruction of
sl@0: KEY and DATA TSqlPair data members.
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR, class DESTRUCTOR> 
sl@0: RSqlMap<KEY, DATA, REFCNTR, DESTRUCTOR>::RSqlMap(const TLinearOrder< TSqlPair<KEY, DATA, REFCNTR> >& aOrder, const DESTRUCTOR& aDestructor) :
sl@0: 	iOrder(aOrder),
sl@0: 	iDestructor(aDestructor)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Closes RSqlMap instance and destroys all RSqlMap data.
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR, class DESTRUCTOR> 
sl@0: void RSqlMap<KEY, DATA, REFCNTR, DESTRUCTOR>::Close()
sl@0: 	{
sl@0: 	TInt idx = iSet.Count();
sl@0: 	while(--idx >= 0)
sl@0: 		{
sl@0: 		TSqlPair<KEY, DATA, REFCNTR>& pair = iSet[idx];
sl@0: 		iDestructor.Destroy(pair.iKey, pair.iData);
sl@0: 		}
sl@0: 	iSet.Close();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: This method will create and insert new (KEY, DATA, REFCNTR) pair in the map.
sl@0: 
sl@0: RSqlMap class maintains a set of reference counted objects.
sl@0: If an object with aKey key is already in the map, no insertion will occur, the reference counter
sl@0: of the existing object will be incremented.
sl@0: 
sl@0: @param aKey The key part of TSqlPair object, which will be inserted
sl@0: @param aData The data part of TSqlPair object, which will be inserted
sl@0: 
sl@0: @return System-wide error code if the insertion fails, reference counter value otherwise.
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR, class DESTRUCTOR> 
sl@0: TInt RSqlMap<KEY, DATA, REFCNTR, DESTRUCTOR>::Insert(const KEY& aKey, const DATA& aData)
sl@0: 	{
sl@0: 	TInt idx = iSet.FindInOrder(TSqlPair<KEY, DATA, REFCNTR>(aKey), iOrder);
sl@0: 	if(idx >= 0)
sl@0: 		{
sl@0: 		return iSet[idx].iRefCounter.Increment();
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		TInt err = iSet.InsertInOrder(TSqlPair<KEY, DATA, REFCNTR>(aKey, aData), iOrder);
sl@0: 		return err == KErrNone ? 1 : err;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: This method removes an element with aKey key from the map.
sl@0: 
sl@0: If there is no such element in the map, the debug verison of the method will panic.
sl@0: 
sl@0: RSqlMap class maintains a set of reference counted objects.
sl@0: If an object with aKey key is in the map, the reference counter of the object will be decremented.
sl@0: If the object's reference counter reaches 0 then the object will be destroyed.
sl@0: 
sl@0: @param aKey The key of TSqlPair object, which has to be removed from the collection.
sl@0: 
sl@0: @panic 7 In _DEBUG mode if there is no entry with aKey key in the RSqlMap container.
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR, class DESTRUCTOR> 
sl@0: void RSqlMap<KEY, DATA, REFCNTR, DESTRUCTOR>::Remove(const KEY& aKey)
sl@0: 	{
sl@0: 	TInt idx = iSet.FindInOrder(TSqlPair<KEY, DATA, REFCNTR>(aKey), iOrder);
sl@0: 	if(idx != KErrNotFound)
sl@0: 		{
sl@0: 		TSqlPair<KEY, DATA, REFCNTR>& pair = iSet[idx];
sl@0: 		if(pair.iRefCounter.Decrement() == 0)
sl@0: 			{
sl@0: 			iDestructor.Destroy(pair.iKey, pair.iData);
sl@0: 			iSet.Remove(idx);
sl@0: #ifdef _DEBUG
sl@0: //This is used prevent the failure of the resource allocation checking in debug mode. 
sl@0:                 if(iSet.Count() == 0)
sl@0:                     {
sl@0:                     iSet.Reset();
sl@0:                     }
sl@0: #endif  
sl@0: 			}
sl@0: 		return;
sl@0: 		}
sl@0: 	__ASSERT_DEBUG(EFalse, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: This method performs a search for an element with aKey key in the map.
sl@0: If such element exists, the method will return a pointer to it.
sl@0: If not, then the method will return NULL.
sl@0: 
sl@0: @param aKey The search key.
sl@0: 
sl@0: @return A pointer to the found element or NULL.
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR, class DESTRUCTOR> 
sl@0: TSqlPair<KEY, DATA, REFCNTR>* RSqlMap<KEY, DATA, REFCNTR, DESTRUCTOR>::Entry(const KEY& aKey)
sl@0: 	{
sl@0: 	TInt idx = iSet.FindInOrder(TSqlPair<KEY, DATA, REFCNTR>(aKey), iOrder);
sl@0: 	return idx == KErrNotFound ? NULL : &iSet[idx];
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////            TSqlMapIterator implementation              ////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: Initializes TSqlMapIterator instance.
sl@0: 
sl@0: @param aMap A const reference to the RSqlMap object, which will be iterated.
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR, class DESTRUCTOR> 
sl@0: TSqlMapIterator<KEY, DATA, REFCNTR, DESTRUCTOR>::TSqlMapIterator(const RSqlMap<KEY, DATA, REFCNTR, DESTRUCTOR>& aMap) :
sl@0: 	iMap(aMap),
sl@0: 	iIndex(0)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: If iterator's current position is not beyond the end of the map,
sl@0: the iterator will retrieve current map entry into aPair argument, advance iterator position
sl@0: by 1 and return ETrue. 
sl@0: 
sl@0: Otherwise the iterator will return EFalse.
sl@0: 
sl@0: @param aPair An output parameter, which references the location, where the next RSqlMap element will be stored.
sl@0: 
sl@0: @return ETrue The next RSqlMap element successfully loaded into aPair parameter. This is not the 
sl@0:               end of RSqlMap collection.
sl@0: @return EFalse The next RSqlMap element successfully loaded into aPair parameter. This is the 
sl@0:               end of RSqlMap collection. Do not call Next() anymore.
sl@0: */
sl@0: template <class KEY, class DATA, class REFCNTR, class DESTRUCTOR> 
sl@0: TBool TSqlMapIterator<KEY, DATA, REFCNTR, DESTRUCTOR>::Next(TSqlPair<KEY, DATA, REFCNTR>& aPair) const
sl@0: 	{
sl@0: 	return (iIndex < iMap.iSet.Count()) ? aPair = iMap.iSet[iIndex++], ETrue : EFalse;
sl@0: 	}