/*

* Copyright (c) 2006-2007 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:  A stack for the base view and filtered views.

*

*/

#include "cpbk2filteredviewstack.h"

// Phonebook 2

#include "cpbk2filteredviewstackelement.h"

// Virtual Phonebook

#include <MVPbkContactViewFiltering.h>

#include <MVPbkContactViewBase.h>

#include <CVPbkContactFindPolicy.h>

// Debugging headers

#include <Pbk2Debug.h>

// System includes

#include <aknsfld.h>

// CONSTANTS

const TInt KSearchLevelArrayGranularity = 2;

/**

 * A helper class for stack element ownership handling.

 */

NONSHARABLE_CLASS( CElementStack ) : public CBase

    {

    public: // Interface

        /**

         * Destructor.

         */

        ~CElementStack();

        /**

         * Returns the number of elements in the stack.

         *

         * @return  Number of elements in the stack.

         */

        TInt Count() const;

        /**

         * Returns an element in given index.

         *

         * @param aIndex    Index.

         * @return  Element at given index.

         */

        MPbk2FilteredViewStackElement& operator[](

                TInt aIndex );

        /**

         * Appends element to the stack.

         *

         * @param aElement  Element to append. Ownership is taken.

         */

        void AppendL(

                MPbk2FilteredViewStackElement* aElement );

        /**

         * Moves elements from given stack to this stack.

         *

         * @param aStack    Elements to append.

         */

        void AppendStackL(

                CElementStack& aStack );

        /**

         * Destroys all element in the stack starting from the top.

         */

        void Reset();

        /**

         * Removes an element from given position. Client must first

         * take the ownership of the element.

         *

         * @param aIndex    Index.

         */

        void Remove(

                TInt aIndex );

        /**

         * Finds the first element under destruction starting from bottom.

         */

        TInt FindFirstElementUnderDestruction();

        /**

         * Reserves memory for given number of items.

         *

         * @param aNumberOfItems    Number of items.

         */

        void ReserveL(

                TInt aNumberOfItems );

        /**

         * Used together with ReserveL. Append doesn't leave if ReserveL has

         * been called earlier.

         *

         * @param aElement  Element to append.

         */

        void Append(

                MPbk2FilteredViewStackElement* aElement );

    private: // Data

        /// Own: Stack of elements

        RPointerArray<MPbk2FilteredViewStackElement> iStack;

    };

/**

 * An internal callback class for handling asynchrnous observer

 * events.

 */

NONSHARABLE_CLASS( CPbk2FilteredViewStack::CCallback ) : public CActive

    {

    public: // Interface

        /**

         * A member function pointer definition for handling AddObserverL

         */

        typedef void(CPbk2FilteredViewStack::* AddObserverL)(

            MVPbkContactViewObserver&, CCallback& );

        /**

         * A member function pointer definition for handling error if

         * AddObserverL -function leaves.

         */

        typedef void(CPbk2FilteredViewStack::* AddObserverError)(

            TInt, CCallback& );

        /**

         * Constructor.

         *

         * @param aViewStack    The parent of this class.

         * @param aObserver     New observer that will given back to

         *                      parent class when the call back completes.

         * @param aAddObserverFuncL     Member function pointer to function

         *                              that handles adding of new observer

         * @param aAddObserverErrorFunc Member function pointer to function

         *                               that handles an error if the

         *                              aAddObserverFuncL leaves.

         */

        CCallback(

                CPbk2FilteredViewStack& aViewStack,

                MVPbkContactViewObserver& aObserver,

                AddObserverL aAddObserverFuncL,

                AddObserverError aAddObserverErrorFunc );

        /**

         * Destructor.

         */

        ~CCallback();

        /**

         * Starts the callback.

         */

        void Execute();

        /**

         * Returns the observer.

         *

         * @return  The observer that were given in construction..

         */

        MVPbkContactViewObserver& Observer();

    private: // From CActive

        void RunL();

        void DoCancel();

        TInt RunError(

                TInt aError );

    private: // Data

        /// Ref: View stack

        CPbk2FilteredViewStack& iViewStack;

        /// Ref: Observer

        MVPbkContactViewObserver& iObserver;

        /// Ref: Add observer function pointer

        AddObserverL iAddObserverFuncL;

        /// Ref: Add observer error function pointer

        AddObserverError iAddObserverErrorFunc;

    };

/// Unnamed namespace for local definitions

namespace {

#ifdef _DEBUG

/**

 * Panic codes for debug build

 */

enum TPanicCode

    {

    EPreCond_ReserveL = 1,

    EPreCond_AppendStackL,

    EInvariantConstructionStackNotIntOrder,

    EInvariantViewStackNotIntOrder,

    EPostCond_Reset

    };

/**

 * A panic function for this class

 */

void Panic(TPanicCode aReason)

    {

    _LIT(KPanicText, "CPbk2FilteredViewStack");

    User::Panic(KPanicText, aReason);

    }

#endif // _DEBUG

// --------------------------------------------------------------------------

// MatchElement

// Matches aElement to an element in aViewStack.

//

// @param aViewStack    Stack of elements.

// @param aElement      The element that is searched for.

// @return  The matched element or NULL.

// --------------------------------------------------------------------------

//

MPbk2FilteredViewStackElement* MatchElement(

        CElementStack& aViewStack,

        MPbk2FilteredViewStackElement& aElement )

    {

    const TInt count = aViewStack.Count();

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

        {

        if ( aViewStack[i].IsSame( aElement ) )

            {

            return &aViewStack[i];

            }

        }

    return NULL;

    }

// --------------------------------------------------------------------------

// FindElement

// Finds an element for the view.

//

// @param aViewStack    Stack of elements.

// @param aView         The view whose element is searched for.

// @return  The element or NULL.

// --------------------------------------------------------------------------

//

MPbk2FilteredViewStackElement* FindElement(

        CElementStack& aViewStack,

        MVPbkContactViewBase& aView )

    {

    const TInt count = aViewStack.Count();

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

        {

        if ( aViewStack[i].View() == &aView )

            {

            return &aViewStack[i];

            }

        }

    return NULL;

    }

// --------------------------------------------------------------------------

// FindElement

// Finds an element for the given filter level.

//

// @param aViewStack    Stack of elements.

// @param aFilterLevel  The level of the element to search for.

// @return  The element or NULL.

// --------------------------------------------------------------------------

//

MPbk2FilteredViewStackElement* FindElement(

        CElementStack& aViewStack,

        TInt aFilterLevel )

    {

    const TInt count = aViewStack.Count();

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

        {

        if ( aViewStack[i].Level() == aFilterLevel )

            {

            return &aViewStack[i];

            }

        }

    return NULL;

    }

// --------------------------------------------------------------------------

// IsStackReady

// The stack is ready if all the elements in the stack are ready.

//

// @param aViewStack    Stack of elements.

// @return  ETrue if the stack is ready.

// --------------------------------------------------------------------------

//

TBool IsStackReady( CElementStack& aViewStack )

    {

    TBool result = ETrue;

    const TInt count = aViewStack.Count();

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

        {

        if ( aViewStack[i].ViewState() !=

             MPbk2FilteredViewStackElement::EReady )

            {

            result = EFalse;

            }

        }

    return result;

    }

// --------------------------------------------------------------------------

// IsStackReadyToUpdate

// The stack is ready to update if all the elements that are not under

// destruction are ready.

//

// @param aViewStack    Stack of elements.

// @return  ETrue if the stack is ready.

// --------------------------------------------------------------------------

//

TBool IsStackReadyToUpdate( CElementStack& aViewStack )

    {

    TBool result = ETrue;

    const TInt count = aViewStack.Count();

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

        {

        if ( !aViewStack[i].UnderDestruction() &&

             aViewStack[i].ViewState() !=

             MPbk2FilteredViewStackElement::EReady )

            {

            result = EFalse;

            }

        }

    return result;

    }

// --------------------------------------------------------------------------

// IsStackUndefined

// The stack is undefined if at least one of the elements in the

// stack is undefined.

//

// @param aViewStack    Stack of elements.

// @return  ETrue if the stack is undefined.

// --------------------------------------------------------------------------

//

TBool IsStackUndefined( CElementStack& aViewStack )

    {

    TBool result = EFalse;

    const TInt count = aViewStack.Count();

    for ( TInt i = 0; i < count && !result; ++i )

        {

        if ( aViewStack[i].ViewState() ==

             MPbk2FilteredViewStackElement::EUndefined )

            {

            result = ETrue;

            }

        }

    return result;

    }

// --------------------------------------------------------------------------

// SendEventToObservers

// Sends events to the array of observes that take MVPbkContactViewBase.

// as a parameter.

//

// @param aView         The parameter for the NotifyFunc.

// @param aObservers    An array of MVPbkContactViewObservers.

// @param aNotifyFunc   A member function pointer of the

//                      MVPbkContactViewObserver.

// --------------------------------------------------------------------------

//

template <class Observer, class NotifyFunc>

void SendEventToObservers( MVPbkContactViewBase& aView,

        RPointerArray<Observer>& aObservers,

        NotifyFunc aNotifyFunc )

    {

    const TInt count = aObservers.Count();

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

        {

        Observer* observer = aObservers[i];

        (observer->*aNotifyFunc)(aView);

        }

    }

// --------------------------------------------------------------------------

// SendEventToObservers

// Sends events to the array of MVPbkContactViewObserver.

// Used for MVPbkContactViewObserver functions that have two extra parameters

// in addition to MVPbkContactViewBase.

//

// @param aView         The first parameter for the NotifyFunc.

// @param aObservers    An array of MVPbkContactViewObserver.

// @param aNotifyFunc   A member function pointer of the

//                      MVPbkContactViewObserver.

// @param aParam1       The second parameter for the aNotifyFunc.

// @param aParam2       The third parameter for the aNotifyFunc.

// --------------------------------------------------------------------------

//

template <class Observer, class FuncPtr, class ParamType1, class ParamType2>

void SendEventToObservers( MVPbkContactViewBase& aView,

        RPointerArray<Observer>& aObservers,

        FuncPtr aNotifyFunc,

        ParamType1 aParam1, ParamType2& aParam2)

    {

    const TInt count = aObservers.Count();

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

        {

        Observer* observer = aObservers[i];

        (observer->*aNotifyFunc)(aView, aParam1, aParam2);

        }

    }

} /// namespace

// --------------------------------------------------------------------------

// CElementStack::~CElementStack

// --------------------------------------------------------------------------

//

CElementStack::~CElementStack()

    {

    Reset();

    }

// --------------------------------------------------------------------------

// CElementStack::Count

// --------------------------------------------------------------------------

//

TInt CElementStack::Count() const

    {

    return iStack.Count();

    }

// --------------------------------------------------------------------------

// CElementStack::operator[]

// --------------------------------------------------------------------------

//

MPbk2FilteredViewStackElement& CElementStack::operator[](

        TInt aIndex )

    {

    return *iStack[aIndex];

    }

// --------------------------------------------------------------------------

// CElementStack::AppendL

// --------------------------------------------------------------------------

//

void CElementStack::AppendL( MPbk2FilteredViewStackElement* aElement )

    {

    iStack.AppendL( aElement );

    }

// --------------------------------------------------------------------------

// CElementStack::AppendStackL

// --------------------------------------------------------------------------

//

void CElementStack::AppendStackL( CElementStack& aStack )

    {

    // It's OK if this stack is empty OR

    // aStack is empty OR

    // the level of last element of this stack is 1 smaller than the first

    // element of the aStack

    __ASSERT_DEBUG( iStack.Count() == 0 ||

                    aStack.Count() == 0 ||

                    ( iStack[iStack.Count()-1]->Level() ==

                      aStack[0].Level() - 1 ),

                    Panic( EPreCond_AppendStackL ) );

    while ( aStack.Count() > 0 )

        {

        // Give ownership of the aStack[i] to iStack

        iStack.AppendL( &aStack[0] );

        aStack.Remove( 0 );

        }

    }

// --------------------------------------------------------------------------

// CElementStack::Reset

// --------------------------------------------------------------------------

//

void CElementStack::Reset()

    {

    // because views in elements are always linked to previous view.

    // Like BaseView<-FindView<-RefineView<-RefineView...

    const TInt count( iStack.Count() );

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

        {

        MPbk2FilteredViewStackElement* element = iStack[i];

        if ( element )

            {

            iStack.Remove(i);

            delete element;

            element = NULL;

            }

        }

    iStack.Close();

    }

// --------------------------------------------------------------------------

// CElementStack::Remove

// --------------------------------------------------------------------------

//

void CElementStack::Remove( TInt aIndex )

    {

    iStack.Remove( aIndex );

    }

// --------------------------------------------------------------------------

// CElementStack::FindFirstElementUnderDestruction

// --------------------------------------------------------------------------

//

TInt CElementStack::FindFirstElementUnderDestruction()

    {

    TInt result = KErrNotFound;

    const TInt count = iStack.Count();

    for ( TInt i = 0; i < count && result == KErrNotFound; ++i )

        {

        if ( iStack[i]->UnderDestruction() )

            {

            result = i;

            }

        }

    return result;