mirror-processhacker/trunk/ProcessHacker.Common/Threading/FastQueue.cs

using System;
using System.Collections;
using System.Collections.Generic;

namespace ProcessHacker.Common.Threading
{
    public class FastQueue<T> : IEnumerable<T>
    {
        private class FastQueueNode<U>
        {
            public U Value;
            public FastQueueNode<U> Next;
        }

        private int _count = 0;
        // The head node. The next pointer of the head node always points 
        // to the least recently added node - the node to dequeue first.
        private FastQueueNode<T> _head;
        // The tail node. This is always the most recently added node.
        private FastQueueNode<T> _tail;
        // Note: all next pointers point to less recently added nodes (i.e. 
        // the next node to dequeue).

        public FastQueue()
        {
            _head = new FastQueueNode<T>();
            _tail = _head;
            _tail.Next = null;
        }

        public int Count
        {
            get { return _count; }
        }

        public T Dequeue()
        {
            throw new NotImplementedException();
        }

        public void Enqueue(T value)
        {
            throw new NotImplementedException();

            FastQueueNode<T> tail;
            FastQueueNode<T> tailNext;
            FastQueueNode<T> node;

            // Create a new queue node.
            node = new FastQueueNode<T>();
            node.Value = value;
            node.Next = null;

            // Add the node to the tail of the list, atomically. 
            // We have to set the next pointer of the current tail node 
            // and then replace the tail pointer with our new node.
            while (true)
            {
                tailNext = _tail.Next;

                while (true)
                {
                    tail = _tail;
                }
            }
        }

        public IEnumerator<T> GetEnumerator()
        {
            return null;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable<T>)this).GetEnumerator();
        }
    }
}