--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines_old/contactsmodel/tsrc/cfixedqueue.h	Fri Jun 11 13:29:23 2010 +0300
@@ -0,0 +1,238 @@
+// 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
+