// Copyright (c) 2008-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

 @InternalComponent

*/

#include "psylogging.h"

#include "cpositionerq.h"

#include "psypanic.h"

#include "tpositionercall.h"

/*

* CPositionerQ::NewL

* Two-phased constructor.

* @param aEnv pointer to the CPositionerEnvironment

*/

CPositionerQ* CPositionerQ::NewL()

    {

    CPositionerQ* self = new( ELeave ) CPositionerQ();

    return self;

    }

/*

* CPositionerQ::CPositionerQ

* C++ default constructor can NOT contain any code, that

* might leave.

*/

CPositionerQ::CPositionerQ()

    {

    }

/*

* CPositionerQ::~CPositionerQ

* Destructor.

*/

CPositionerQ::~CPositionerQ()

    {

    __ASSERT_DEBUG(iPsyArray.Count() == 0, User::Panic(KAdaptationPanicCategory, EPanicQNotEmpty));

    iPsyArray.Close();

    }

/**

* Registers the PSY instance to the request handler

* @param aPSY pointer to the MPositioner

*/

void CPositionerQ::RegisterPSYL(MPositioner* aPSY)

    {

    TRACESTRING("CPositionerQ::RegisterPSYL start...")

    //Register the psy

    User::LeaveIfError(iPsyArray.Append(aPSY));

    TRACESTRING("CPositionerQ::RegisterPSYL end")

    }

/**

* Unregisters the MPositioner instance

* @param aPSY pointer to the MPositioner

*/

void CPositionerQ::UnregisterPSY(MPositioner* aPSY)

    {

    TRACESTRING("CPositionerQ::UnregisterPSY start...")

    TInt index = KErrNotFound;

    index = Index(*aPSY);

    if(index!=KErrNotFound)

        {

        iPsyArray.Remove(index);

        }

    TRACESTRING("CPositionerQ::UnregisterPSY end")

    }

/**

* Calles aCall::Call for all MPositioners in the queue

* @param TPositionerCall* pointer to the TPositionerCall derived class

*/

void CPositionerQ::PositionerIterator(TPositionerCall& aCall)

	{

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

		{

		aCall.Call(Positioner(i));

		}

	}

/**

* CPositionerQ::IterETrue

* Calls aCall::Call for all MPositioners in the queue

* @param aCall reference to the TPositionerCall derived function to be called

* @return TBool	returns True if the call returns true for any positioner in the queue

*/

TBool CPositionerQ::IterETrue(TRetBoolPositionerCall& aCall)

	{

    TInt count = iPsyArray.Count();

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

        {

        if(aCall.Call(Positioner(i)))

            {

            return ETrue;

            }

        }

    return EFalse;

	}

/**

* CPositionerQ::IterGreatest

* 

* Calls aCall::Call for all MPositioners in the queue

* @param aCall reference to the TPositionerCall derived function to be called

* @return TBool	returns the greatest of all the integer values returned from each MPositioner method

*/

TUint CPositionerQ::IterGreatest(TRetTUintPositionerCall& aCall)

	{

    TInt count = iPsyArray.Count();

    TUint greatest = 0;

    TUint result = 0;

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

        {

        result = aCall.Call(Positioner(i));

        if(result > greatest)

            {

            greatest = result;

            }

        }

    return greatest;

	}

/*

* CPositionerQ::Count

*

* @return count of MPositioner objects in the queue

*/

TUint CPositionerQ::Count()

	{

	return iPsyArray.Count();

	}

TInt CPositionerQ::Index(MPositioner& aPSY)

    {

    TInt index = KErrNotFound;

    TInt count = iPsyArray.Count();

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

        {

        if(iPsyArray[i] == &aPSY)

            {

            index = i;

            }

        }

	return index;

	}    

/*

* CPositionerQ::Positioner

*

* @return MPositioner pointer for requested index

*/

MPositioner& CPositionerQ::Positioner(TUint aIndex)

	{

	return *(iPsyArray[aIndex]);

	}

//  End of File