/*

* Copyright (c) 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: 

*

*/

using System;

using System.Collections;

using System.Collections.Generic;

using System.Text;

using System.Threading;

namespace SymbianUtils.Threading

{

    public class BlockingQueue<T> : ICollection, IEnumerable 

    {

        #region Constructors

        public BlockingQueue()

            : this( -1 )

        {

        }

        public BlockingQueue( int aMaxSize )

        {

            iMaxSize = aMaxSize;

            iQueue = new Queue<T>();

        }

        #endregion

        #region API

        public void Enqueue( T aItem )

        {

            lock ( this.SyncRoot )

            {

                // We want to prevent the queue from growing beyond it's own

                // bounds, unless the creator requested an unbounded queue.

                if ( iMaxSize > 0 )

                {

                    while ( this.Count >= iMaxSize )

                    {

                        try

                        {

                            Monitor.Wait( this.SyncRoot );

                        }

                        catch

                        {

                            Monitor.PulseAll( this.SyncRoot );

                            throw;

                        }

                    }

                }

                // Now it's okay to add the item

                iQueue.Enqueue( aItem );

                // If the count is now one, then we've just added the first

                // item, in which case we must pulse the monitor because

                // there could be blocked threads that are stuck inside the Dequeue()

                // method, waiting for published content.

                int count = this.Count;

                if ( count == 1 )

                {

                    Monitor.PulseAll( this.SyncRoot );

                }

            }

        }

        public bool TryToDequeue( out T aItem )

        {

            bool ret = false;

            aItem = default( T );

            //

            lock ( this.SyncRoot )

            {

                if ( this.Count > 0 )

                {

                    aItem = iQueue.Dequeue();

                    ret = true;

                }

            }

            //

            return ret;

        }

        public void Clear()

        {

            lock ( this.SyncRoot )

            {

                iQueue.Clear();

                // Pulse, since clearing the items might allow a thread blocked

                // inside Enqueue() to push something to the head of the list

                Monitor.PulseAll( this.SyncRoot );

            }

        }

        public T Dequeue()

        {

            lock ( this.SyncRoot )

            {

                // Wait until the queue contains some content.

                while ( this.Count == 0 )

                {

                    try

                    {

                        Monitor.Wait( this.SyncRoot );

                    }

                    catch

                    {

                        Monitor.PulseAll( this.SyncRoot );

                        throw;

                    }

                }

                T ret = iQueue.Dequeue();

                // We dequeue the item and then check to see if we have

                // just opened up the first free slot in the queue.

                // If so, we must pulse the monitor because there could be

                // threads blocked inside the Enqueue() method that are waiting

                // for space to become available.

                int count = this.Count;

                if ( iMaxSize > 0 && count == iMaxSize - 1 )

                {

                    Monitor.PulseAll( this.SyncRoot );

                }

                //

                return ret;

            }

        }

        public T Peek()

        {

            lock ( this.SyncRoot )

            {

                return iQueue.Peek();

            }

        }

        public bool Contains( T aItem )

        {

            lock ( this.SyncRoot )

            {

                bool ret = iQueue.Contains( aItem );

                return ret;

            }

        }

        public T[] ToArray()

        {

            lock ( this.SyncRoot )

            {

                T[] ret = iQueue.ToArray();

                return ret;

            }

        }

        #endregion

        #region From IEnumerable

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()

        {

            throw new NotImplementedException( "You cannot enumerate a Blocking Queue - get the values and enumerate those instead" );

        }

        #endregion

        #region From ICollection

        public void CopyTo( Array aArray, int aIndex )

        {

            lock ( this.SyncRoot )

            {

                ICollection baseCol = (ICollection) iQueue;

                baseCol.CopyTo( aArray, aIndex );

            }

        }

        public int Count

        {

            get

            {

                lock ( this.SyncRoot )

                {

                    return iQueue.Count;

                }

            }

        }

        public bool IsSynchronized

        {

            get { return true; }

        }

        public object SyncRoot

        {

            get 

            {

                if ( this.iSyncRoot == null )

                {

                    Interlocked.CompareExchange( ref this.iSyncRoot, new object(), null );

                }

                return iSyncRoot; 

            }

        }

        #endregion

        #region Data members

        private readonly Queue<T> iQueue;

        private object iSyncRoot = null;

        private readonly int iMaxSize;

        #endregion

    }

}