/*

 * Copyright (c) 2002-2005 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:    Pointermap class declaration        

 *

 */

 #ifndef POINTERMAP_H

 #define POINTERMAP_H

 // INCLUDES

 #include <e32std.h>

 // CLASS DECLARATION

 template <typename K, typename V>

 class RSenPointerMap

     {

     public: // Constructors and destructor

     RSenPointerMap(TBool aTakeOwnershipKey, TBool aTakeOwnershipValue)

         :

         iTakeOwnershipKey(aTakeOwnershipKey),

         iTakeOwnershipValue(aTakeOwnershipValue)

         {}

     ~RSenPointerMap()

         {

         Reset();

         }

         // New functions

     TInt Append(const K* aKey, const V* aValue)

         {

         TInt err = iKeys.Append(aKey);

         if (err == KErrNone)

             {

             err = iValues.Append(aValue);

             if (err != KErrNone)

                 {

                 // last element of iKeys should be removed

                 TInt lastElementIndex = iKeys.Count() - 1;

                 iKeys.Remove(lastElementIndex);

                 }

             }

         return err;

         }

     TInt Find(const K& aKey) const

         {

         TInt index( KErrNotFound );

         for (TInt i = 0; i < iKeys.Count(); i++)

             {

             if (*iKeys[i] == aKey)

                 {

                 index = i;

                 break;

                 }

             }

         return index;

         }

     TInt FindReverse(const K& aKey) const

         {

         TInt index( KErrNotFound );

         TInt count( iKeys.Count() );

         for (TInt i = count-1; i >=0 ; i--)

             {

             if (*iKeys[i] == aKey)

                 {

                 index = i;

                 break;

                 }

             }

         return index;

         }

     TInt RemoveAt( TInt aIndex ) 

         {

         K* key = KeyAt( aIndex );

     	return RemoveByKey( *key );

     	}

     // @return the index of removed key-value pair, or

     // KErrNotFound, if such key was not found

     TInt RemoveByKey(const K& aKey)

         {

         TInt index = Find(aKey);

         if (index != KErrNotFound)

             {

             if(iTakeOwnershipKey)

                 {

                 K* key = KeyAt(index);

                 delete key;

                 }

             if(iTakeOwnershipValue)

                 {

                 V* value = iValues[index];

                 delete value;

                 }

             iKeys.Remove(index);

             iValues.Remove(index);

             }

         return index;

         }

     // @return the index of removed key-value pair, or

     // KErrNotFound, if such key was not found

     TInt Remove(const V& aValue)

         {

         TInt index = FindValue(aValue);

         if (index != KErrNotFound)

             {

             if (iTakeOwnershipValue)

                 {

                 V* value = iValues[index];

                 delete value;

                 }

             if (iTakeOwnershipKey)

                 {

                 K* key = iKeys[index];

                 delete key;

                 }

             iValues.Remove(index);

             iKeys.Remove(index);

             }

         return index; 

         }

     TInt FindValue(const V& aValue) const

         {

         TInt index = KErrNotFound;

         for (TInt i = 0; i < iValues.Count(); i++)

             {

             if ((iValues[i]) && (*iValues[i] == aValue))

                 {

                 index = i;

                 break;

                 }

             }

         return index;

         }

     // Note: deletes the current value of this key

     TInt UpdateValue(const K* aKey, const V* aValue)

         {

         TInt index=Find(*aKey);

         if (index==KErrNotFound)

             {

             return Append(aKey, aValue);

             }

         V* bValue=iValues[index];

         if (iTakeOwnershipValue)

             {

             // Since OWNED value is going to be replaced with aValue,

             // destroy old value instance first:

             delete bValue;  

             }

         iValues[index]=(V*)aValue;

         return KErrNone;

         }

     K* KeyAt(TInt aIndex)

         {

         return iKeys[aIndex];

         }

     const V* ValueAt(TInt aIndex) const

         {

         return iValues[aIndex];

         }

     TInt Count() const

         {

         return iKeys.Count();

         }

     void Reset()

         {

         if ( iTakeOwnershipKey )

             {

             iKeys.ResetAndDestroy();

             }

         else

             {

             iKeys.Reset();

             }

         if ( iTakeOwnershipValue )

             {

             iValues.ResetAndDestroy();

             }

         else

             {

             iValues.Reset();

             }

         }

     TInt Insert(const K* aKey, const V* aValue)

         {

         TInt count=iKeys.Count();

         TInt err=KErrNone;

 		TBool inserted=EFalse;

         for(TInt i=0; i<count; i++)

         	{

         	 if(*iKeys[i] >= *aKey)

         	 {

 	        err = iKeys.Insert(aKey, i);

 	        if (err == KErrNone)

 	            {

 	            err = iValues.Insert(aValue, i);

 	            if (err != KErrNone)

 	                {

 	                // inserted element of iKeys should be removed

 	                iKeys.Remove(i);

 	                }

 				    else

 					{

 					inserted=ETrue;

 					}

             	}

 			break;  	 	

         	 }

 			}

         if(!inserted)

         	{

 	        err = iKeys.Append(aKey);

 	        if (err == KErrNone)

 	            {

 	            err = iValues.Append(aValue);

 	            if (err != KErrNone)

 	                {

 	                // last element of iKeys should be removed

 	                TInt lastElementIndex = iKeys.Count() - 1;

 	                iKeys.Remove(lastElementIndex);

 	                }

             	}

         	}

 	return err;

         }

     private: // Data

     TBool iTakeOwnershipKey;

     TBool iTakeOwnershipValue;

     RPointerArray<K> iKeys;

     RPointerArray<V> iValues;

     };

 #endif // POINTERMAP_H

 // End of File