// Copyright (c) 2006-2009 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:

//

/**

 @file

 @internalTechnology

*/

#ifndef CMTPHANDLEALLOCATOR_H

#define CMTPHANDLEALLOCATOR_H

#include <e32base.h>

class CMTPObjectStore;

/** 

Defines the handle allocator which centralize the allocation of object handles

@internalTechnology

*/

class CMTPHandleAllocator : public CBase

	{

public:

	static CMTPHandleAllocator* NewL( CMTPObjectStore& aObjectStore );

	~CMTPHandleAllocator();

	TUint32 NextIdL(TUint aDataProviderId);

	void SetIdL( TUint32 aHandleID, TInt64 aPOUID );

	TInt64 NextPOUIDL();

   TBool AppendHandleBlockL( TUint aDataProviderId, TUint aNextID, TInt aSpace );

private:

	CMTPHandleAllocator( CMTPObjectStore& aObjectStore );	

	void ConstructL();

    void ExtendArrayL(TUint aDataProviderId);

	TUint32 NextIDFromPoolL( TUint aDataProviderId );

    /*

     * Defines the HandleID cache of one data provider. The HandleIDs have been allocated, but now

     * they are available because the corresponding Object have been deleted or ... 

     *  

     * When the HandleID of one data provider is over flow, we have to search the DB to get the available

     * HandleIDs that are not registed in DB.

     * 

     */

    class CDPHandleCache : public CBase

        {

    public:

        class THandleBlock

            {

            public:

                THandleBlock( TUint aNextID, TInt aSpace );

            public:

                TUint    iNextID;

                TInt     iSpace;

            };

    public:

        static TInt HanldeCacheOrderFromAscending( const CDPHandleCache& aL, const CDPHandleCache& aR);

        static TInt HanldeCacheOrderFromKeyAscending( const TUint* aL, const CDPHandleCache& aR);

    public:

        static CDPHandleCache* NewLC( TUint aDataProviderId );

        ~CDPHandleCache();

        TUint32 NextHandleID();

        void AppendL( const THandleBlock& aBlock );

        inline TUint DPID() const

            {

            return iDPID;

            }

        inline TBool HasCache() const

            {

            return (iBlocks.Count() != 0);

            }

        inline TInt  BlocksCount() const

            {

            return iBlocks.Count();

            }

        static inline TInt MaxNumOfBlocks()

            {

            return iNumOfBlocks;

            }

    private:

        CDPHandleCache(TUint aDataProviderId);

        void ConstructL();

    private:

        /*

         * The number of blocks 

         */

        static const TInt           iNumOfBlocks = 10;

        /*

         * Data Provider ID

         */

        TUint                       iDPID;

        /*

         * HandleID Blocks

         */

        RArray<THandleBlock>        iBlocks;

        };

private:

    CMTPObjectStore&                iObjectStore;

	RArray<TUint>					iNextIds;	

	TInt64							iNextPOUID;

	//For ObjectID overflow

	RPointerArray<CDPHandleCache>   iNextIDPool;

	};

#endif //CMTPHANDLEALLOCATOR_H