/*

* 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:    Header 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