// Copyright (c) 2003-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:
// CFixedQueue Test module
// 
//


#ifndef CFixedQueue_H
#define CFixedQueue_H

// INCLUDES
#include <e32base.h>


// CONSTANTS
_LIT(KFixedQueuePanicText, "CFixedQueue<T>");


// CLASS DECLARATION

/**
 * Fixed size queue.
 * @param T type of objects in the queue. T must have accessible default 
 *          constructor and assignment operator.
 */
template<class T>
class CFixedQueue : public CBase
    {
    public:  // Constructors and destructor
        CFixedQueue();

        /**
         * Initializes a new fixed queue.
         * @param aSize maximum size of the queue.
         * @pre aSize > 0
         */
        void ConstructL(TInt aSize);

        /**
         * Destructor.
         */
        ~CFixedQueue();

    public:  // Interface
        /**
         * Returns the object at the head of this queue.
         * @pre !IsEmpty()
         */
        T& Head() const;

        /**
         * Pops the head off this queue. Does not deallocate memory.
         * @pre !IsEmpty()
         */
        void PopHead();

        /**
         * Returns true if this queue is empty
         */
        TBool IsEmpty() const;

        /**
         * Returns the number of objects in the queue.
         */
        TInt Count() const;

        /**
         * Pushes an object at the tail of the queue.
         * @return ETrue if succesful, EFalse if queue run out of space.
         */ 
        TBool Push(const T& aObj);

        /**
         * Empties this queue. Does not deallocate memory.
         */
        void Reset();

    private:  // Implementation
        enum TPanicCode
            {
            EPanicPreCond_ConstructL = 1,
            EPanicPreCond_Head,
            EPanicPreCond_PopHead,
            EPanicPreCond_Push,
            EPanicInvariant
            };
        static void Panic(TPanicCode aReason);
        __DECLARE_TEST;

    private:  // Data
        // Own: circural queue array
        T* iQueueArray;
        // Own: maximum size of queue
        TInt iQueueSize;
        // Own: number of objects currently in the queue
        TInt iCount;
        // Ref: head of queue
        T* iQueueHead;
        // Ref: tail of queue
        T* iQueueTail;
    };

template<class T> inline
void CFixedQueue<T>::Panic(TPanicCode aReason)
    {
    User::Panic(KFixedQueuePanicText,aReason);
    }

template<class T> inline
CFixedQueue<T>::CFixedQueue()
    {
    // CBase::operator new resets memebers
    __TEST_INVARIANT;
    }

template<class T> inline
void CFixedQueue<T>::ConstructL(TInt aSize)
    {
    __TEST_INVARIANT;
    __ASSERT_ALWAYS(!iQueueArray, Panic(EPanicPreCond_ConstructL));
    __ASSERT_ALWAYS(aSize > 0, Panic(EPanicPreCond_ConstructL));
    iQueueArray = new(ELeave) T[aSize];
    iQueueSize = aSize;
    iCount = 0;
    iQueueHead = iQueueTail = iQueueArray;
    __TEST_INVARIANT;
    }

template<class T>
CFixedQueue<T>::~CFixedQueue()
    {
    __TEST_INVARIANT;
    delete [] iQueueArray;
    }

template<class T> inline
T& CFixedQueue<T>::Head() const
    {
    __TEST_INVARIANT;
    __ASSERT_ALWAYS(iCount > 0, Panic(EPanicPreCond_Head));
    return *iQueueHead;
    }

template<class T> inline
void CFixedQueue<T>::PopHead()
    {
    __TEST_INVARIANT;
    __ASSERT_ALWAYS(iCount > 0, Panic(EPanicPreCond_PopHead));
    ++iQueueHead;
    if (iQueueHead == iQueueArray+iQueueSize)
        {
        iQueueHead = iQueueArray;
        }
    --iCount;
    }

template<class T> inline
TBool CFixedQueue<T>::IsEmpty() const
    {
    __TEST_INVARIANT;
    return (iCount==0);
    }

template<class T> inline
TInt CFixedQueue<T>::Count() const
    {
    __TEST_INVARIANT;
    return iCount;
    }

template<class T> inline
TBool CFixedQueue<T>::Push(const T& aObj)
    {
    __TEST_INVARIANT;
    if (iCount < iQueueSize)
        {
        *iQueueTail = aObj;
        ++iQueueTail;
        if (iQueueTail == iQueueArray+iQueueSize)
            {
            iQueueTail = iQueueArray;
            }
        ++iCount;
        __TEST_INVARIANT;
        return ETrue;
        }
    else
        {
        return EFalse;
        }
    }

template<class T> inline
void CFixedQueue<T>::Reset()
    {
    __TEST_INVARIANT;
    iQueueTail = iQueueHead;
    iCount = 0;
    __TEST_INVARIANT;
    }

template<class T>
void CFixedQueue<T>::__DbgTestInvariant() const
    {
    if (!iQueueArray)
        {
        // Not initialised
        __ASSERT_ALWAYS(iQueueSize==0 && iCount==0, Panic(EPanicInvariant));
        __ASSERT_ALWAYS(!iQueueHead && !iQueueTail, Panic(EPanicInvariant));
        }
    else
        {
        // Initialised
        __ASSERT_ALWAYS(iQueueSize > 0, Panic(EPanicInvariant));
        __ASSERT_ALWAYS(iCount >= 0 && iCount <= iQueueSize, Panic(EPanicInvariant));
        __ASSERT_ALWAYS((iQueueHead >= iQueueArray) && (iQueueHead < iQueueArray+iQueueSize), 
            Panic(EPanicInvariant));
        __ASSERT_ALWAYS((iQueueTail >= iQueueArray) && (iQueueTail < iQueueArray+iQueueSize), 
            Panic(EPanicInvariant));
        }
    }


#endif

// End of File