Fix SmartThreadPool line endings in recent update from dos to unix

1 files changed, 239 insertions, 239 deletions

diff --git a/ThirdParty/SmartThreadPool/PriorityQueue.cs b/ThirdParty/SmartThreadPool/PriorityQueue.cs
index 6245fd8..409c879 100644
--- a/ThirdParty/SmartThreadPool/PriorityQueue.cs
+++ b/ThirdParty/SmartThreadPool/PriorityQueue.cs
@@ -1,239 +1,239 @@
-using System;

-using System.Collections;

-using System.Collections.Generic;

-using System.Diagnostics;

-

-namespace Amib.Threading.Internal

-{

-        #region PriorityQueue class

-

-        /// <summary>

-        /// PriorityQueue class

-        /// This class is not thread safe because we use external lock

-        /// </summary>

-        public sealed class PriorityQueue : IEnumerable

-        {

-                #region Private members

-

-                /// <summary>

-                /// The number of queues, there is one for each type of priority

-                /// </summary>

-                private const int _queuesCount = WorkItemPriority.Highest-WorkItemPriority.Lowest+1;

-

-                /// <summary>

-                /// Work items queues. There is one for each type of priority

-                /// </summary>

-        private readonly LinkedList<IHasWorkItemPriority>[] _queues = new LinkedList<IHasWorkItemPriority>[_queuesCount];

-

-                /// <summary>

-                /// The total number of work items within the queues 

-                /// </summary>

-                private int _workItemsCount;

-

-                /// <summary>

-                /// Use with IEnumerable interface

-                /// </summary>

-                private int _version;

-

-                #endregion

-

-                #region Contructor

-

-                public PriorityQueue()

-                {

-                        for(int i = 0; i < _queues.Length; ++i)

-                        {

-                _queues[i] = new LinkedList<IHasWorkItemPriority>();

-                        }

-                }

-

-                #endregion

-

-                #region Methods

-

-                /// <summary>

-                /// Enqueue a work item.

-                /// </summary>

-                /// <param name="workItem">A work item</param>

-                public void Enqueue(IHasWorkItemPriority workItem)

-                {

-                        Debug.Assert(null != workItem);

-

-                        int queueIndex = _queuesCount-(int)workItem.WorkItemPriority-1;

-                        Debug.Assert(queueIndex >= 0);

-                        Debug.Assert(queueIndex < _queuesCount);

-

-                        _queues[queueIndex].AddLast(workItem);

-                        ++_workItemsCount;

-                        ++_version;

-                }

-

-                /// <summary>

-                /// Dequeque a work item.

-                /// </summary>

-                /// <returns>Returns the next work item</returns>

-                public IHasWorkItemPriority Dequeue()

-                {

-                        IHasWorkItemPriority workItem = null;

-

-                        if(_workItemsCount > 0)

-                        {

-                                int queueIndex = GetNextNonEmptyQueue(-1);

-                                Debug.Assert(queueIndex >= 0);

-                workItem = _queues[queueIndex].First.Value;

-                                _queues[queueIndex].RemoveFirst();

-                                Debug.Assert(null != workItem);

-                                --_workItemsCount;

-                                ++_version;

-                        }

-

-                        return workItem;

-                }

-

-                /// <summary>

-                /// Find the next non empty queue starting at queue queueIndex+1

-                /// </summary>

-                /// <param name="queueIndex">The index-1 to start from</param>

-                /// <returns>

-                /// The index of the next non empty queue or -1 if all the queues are empty

-                /// </returns>

-                private int GetNextNonEmptyQueue(int queueIndex)

-                {

-                        for(int i = queueIndex+1; i < _queuesCount; ++i)

-                        {

-                                if(_queues[i].Count > 0)

-                                {

-                                        return i;

-                                }

-                        }

-                        return -1;

-                }

-

-                /// <summary>

-                /// The number of work items 

-                /// </summary>

-                public int Count

-                {

-                        get

-                        {

-                                return _workItemsCount;

-                        }

-                }

-

-                /// <summary>

-                /// Clear all the work items 

-                /// </summary>

-                public void Clear()

-                {

-                        if (_workItemsCount > 0)

-                        {

-                                foreach(LinkedList<IHasWorkItemPriority> queue in _queues)

-                                {

-                                        queue.Clear();

-                                }

-                                _workItemsCount = 0;

-                                ++_version;

-                        }

-                }

-

-                #endregion

-

-                #region IEnumerable Members

-

-                /// <summary>

-                /// Returns an enumerator to iterate over the work items

-                /// </summary>

-                /// <returns>Returns an enumerator</returns>

-                public IEnumerator GetEnumerator()

-                {

-                        return new PriorityQueueEnumerator(this);

-                }

-

-                #endregion

-

-                #region PriorityQueueEnumerator

-

-                /// <summary>

-                /// The class the implements the enumerator

-                /// </summary>

-                private class PriorityQueueEnumerator : IEnumerator

-                {

-                        private readonly PriorityQueue _priorityQueue;

-                        private int _version;

-                        private int _queueIndex;

-                        private IEnumerator _enumerator;

-

-                        public PriorityQueueEnumerator(PriorityQueue priorityQueue)

-                        {

-                                _priorityQueue = priorityQueue;

-                                _version = _priorityQueue._version;

-                                _queueIndex = _priorityQueue.GetNextNonEmptyQueue(-1);

-                                if (_queueIndex >= 0)

-                                {

-                                        _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();

-                                }

-                                else

-                                {

-                                        _enumerator = null;

-                                }

-                        }

-

-                        #region IEnumerator Members

-

-                        public void Reset()

-                        {

-                                _version = _priorityQueue._version;

-                                _queueIndex = _priorityQueue.GetNextNonEmptyQueue(-1);

-                                if (_queueIndex >= 0)

-                                {

-                                        _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();

-                                }

-                                else

-                                {

-                                        _enumerator = null;

-                                }

-                        }

-

-                        public object Current

-                        {

-                                get

-                                {

-                                        Debug.Assert(null != _enumerator);

-                                        return _enumerator.Current;

-                                }

-                        }

-

-                        public bool MoveNext()

-                        {

-                                if (null == _enumerator)

-                                {

-                                        return false;

-                                }

-

-                                if(_version != _priorityQueue._version)

-                                {

-                                        throw new InvalidOperationException("The collection has been modified");

-

-                                }

-                                if (!_enumerator.MoveNext())

-                                {

-                                        _queueIndex = _priorityQueue.GetNextNonEmptyQueue(_queueIndex);

-                                        if(-1 == _queueIndex)

-                                        {

-                                                return false;

-                                        }

-                                        _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();

-                                        _enumerator.MoveNext();

-                                        return true;

-                                }

-                                return true;

-                        }

-

-                        #endregion

-                }

-

-                #endregion

-        }

-

-        #endregion

-}

+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace Amib.Threading.Internal
+{
+        #region PriorityQueue class
+
+        /// <summary>
+        /// PriorityQueue class
+        /// This class is not thread safe because we use external lock
+        /// </summary>
+        public sealed class PriorityQueue : IEnumerable
+        {
+                #region Private members
+
+                /// <summary>
+                /// The number of queues, there is one for each type of priority
+                /// </summary>
+                private const int _queuesCount = WorkItemPriority.Highest-WorkItemPriority.Lowest+1;
+
+                /// <summary>
+                /// Work items queues. There is one for each type of priority
+                /// </summary>
+        private readonly LinkedList<IHasWorkItemPriority>[] _queues = new LinkedList<IHasWorkItemPriority>[_queuesCount];
+
+                /// <summary>
+                /// The total number of work items within the queues 
+                /// </summary>
+                private int _workItemsCount;
+
+                /// <summary>
+                /// Use with IEnumerable interface
+                /// </summary>
+                private int _version;
+
+                #endregion
+
+                #region Contructor
+
+                public PriorityQueue()
+                {
+                        for(int i = 0; i < _queues.Length; ++i)
+                        {
+                _queues[i] = new LinkedList<IHasWorkItemPriority>();
+                        }
+                }
+
+                #endregion
+
+                #region Methods
+
+                /// <summary>
+                /// Enqueue a work item.
+                /// </summary>
+                /// <param name="workItem">A work item</param>
+                public void Enqueue(IHasWorkItemPriority workItem)
+                {
+                        Debug.Assert(null != workItem);
+
+                        int queueIndex = _queuesCount-(int)workItem.WorkItemPriority-1;
+                        Debug.Assert(queueIndex >= 0);
+                        Debug.Assert(queueIndex < _queuesCount);
+
+                        _queues[queueIndex].AddLast(workItem);
+                        ++_workItemsCount;
+                        ++_version;
+                }
+
+                /// <summary>
+                /// Dequeque a work item.
+                /// </summary>
+                /// <returns>Returns the next work item</returns>
+                public IHasWorkItemPriority Dequeue()
+                {
+                        IHasWorkItemPriority workItem = null;
+
+                        if(_workItemsCount > 0)
+                        {
+                                int queueIndex = GetNextNonEmptyQueue(-1);
+                                Debug.Assert(queueIndex >= 0);
+                workItem = _queues[queueIndex].First.Value;
+                                _queues[queueIndex].RemoveFirst();
+                                Debug.Assert(null != workItem);
+                                --_workItemsCount;
+                                ++_version;
+                        }
+
+                        return workItem;
+                }
+
+                /// <summary>
+                /// Find the next non empty queue starting at queue queueIndex+1
+                /// </summary>
+                /// <param name="queueIndex">The index-1 to start from</param>
+                /// <returns>
+                /// The index of the next non empty queue or -1 if all the queues are empty
+                /// </returns>
+                private int GetNextNonEmptyQueue(int queueIndex)
+                {
+                        for(int i = queueIndex+1; i < _queuesCount; ++i)
+                        {
+                                if(_queues[i].Count > 0)
+                                {
+                                        return i;
+                                }
+                        }
+                        return -1;
+                }
+
+                /// <summary>
+                /// The number of work items 
+                /// </summary>
+                public int Count
+                {
+                        get
+                        {
+                                return _workItemsCount;
+                        }
+                }
+
+                /// <summary>
+                /// Clear all the work items 
+                /// </summary>
+                public void Clear()
+                {
+                        if (_workItemsCount > 0)
+                        {
+                                foreach(LinkedList<IHasWorkItemPriority> queue in _queues)
+                                {
+                                        queue.Clear();
+                                }
+                                _workItemsCount = 0;
+                                ++_version;
+                        }
+                }
+
+                #endregion
+
+                #region IEnumerable Members
+
+                /// <summary>
+                /// Returns an enumerator to iterate over the work items
+                /// </summary>
+                /// <returns>Returns an enumerator</returns>
+                public IEnumerator GetEnumerator()
+                {
+                        return new PriorityQueueEnumerator(this);
+                }
+
+                #endregion
+
+                #region PriorityQueueEnumerator
+
+                /// <summary>
+                /// The class the implements the enumerator
+                /// </summary>
+                private class PriorityQueueEnumerator : IEnumerator
+                {
+                        private readonly PriorityQueue _priorityQueue;
+                        private int _version;
+                        private int _queueIndex;
+                        private IEnumerator _enumerator;
+
+                        public PriorityQueueEnumerator(PriorityQueue priorityQueue)
+                        {
+                                _priorityQueue = priorityQueue;
+                                _version = _priorityQueue._version;
+                                _queueIndex = _priorityQueue.GetNextNonEmptyQueue(-1);
+                                if (_queueIndex >= 0)
+                                {
+                                        _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();
+                                }
+                                else
+                                {
+                                        _enumerator = null;
+                                }
+                        }
+
+                        #region IEnumerator Members
+
+                        public void Reset()
+                        {
+                                _version = _priorityQueue._version;
+                                _queueIndex = _priorityQueue.GetNextNonEmptyQueue(-1);
+                                if (_queueIndex >= 0)
+                                {
+                                        _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();
+                                }
+                                else
+                                {
+                                        _enumerator = null;
+                                }
+                        }
+
+                        public object Current
+                        {
+                                get
+                                {
+                                        Debug.Assert(null != _enumerator);
+                                        return _enumerator.Current;
+                                }
+                        }
+
+                        public bool MoveNext()
+                        {
+                                if (null == _enumerator)
+                                {
+                                        return false;
+                                }
+
+                                if(_version != _priorityQueue._version)
+                                {
+                                        throw new InvalidOperationException("The collection has been modified");
+
+                                }
+                                if (!_enumerator.MoveNext())
+                                {
+                                        _queueIndex = _priorityQueue.GetNextNonEmptyQueue(_queueIndex);
+                                        if(-1 == _queueIndex)
+                                        {
+                                                return false;
+                                        }
+                                        _enumerator = _priorityQueue._queues[_queueIndex].GetEnumerator();
+                                        _enumerator.MoveNext();
+                                        return true;
+                                }
+                                return true;
+                        }
+
+                        #endregion
+                }
+
+                #endregion
+        }
+
+        #endregion
+}