Created S# .sln and moved project to src folder

ICD.Common/Utils/Collections/ScrollQueue.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using ICD.Common.Properties;
+
+namespace ICD.Common.Utils.Collections
+{
+	/// <summary>
+	///	ScrollQueue is a queue that never exceeds a predefined length. Old items
+	///	are removed as new items are added.
+	/// </summary>
+	/// <typeparam name="TContents"></typeparam>
+	public sealed class ScrollQueue<TContents> : IEnumerable<TContents>, ICollection
+	{
+		private readonly LinkedList<TContents> m_Collection;
+		private int m_MaxSize;
+
+		private readonly SafeCriticalSection m_CollectionLock;
+
+		#region Properties
+
+		/// <summary>
+		/// Gets/sets the maximum size of the queue.
+		/// </summary>
+		[PublicAPI]
+		public int MaxSize
+		{
+			get { return m_MaxSize; }
+			set
+			{
+				if (value == m_MaxSize)
+					return;
+
+				m_MaxSize = value;
+
+				Trim();
+			}
+		}
+
+		/// <summary>
+		/// Gets the number of items in the collection.
+		/// </summary>
+		public int Count { get { return m_CollectionLock.Execute(() => m_Collection.Count); } }
+
+		/// <summary>
+		/// The IsSynchronized Boolean property returns True if the 
+		/// collection is designed to be thread safe; otherwise, it returns False.
+		/// </summary>
+		public bool IsSynchronized { get { return true; } }
+
+		/// <summary>
+		/// The SyncRoot property returns an object, which is used for synchronizing 
+		/// the collection. This returns the instance of the object or returns the 
+		/// SyncRoot of other collections if the collection contains other collections.
+		/// </summary>
+		public object SyncRoot { get { return this; } }
+
+		#endregion
+
+		/// <summary>
+		/// Constructor.
+		/// </summary>
+		/// <param name="maxSize"></param>
+		public ScrollQueue(int maxSize)
+		{
+			m_CollectionLock = new SafeCriticalSection();
+			m_Collection = new LinkedList<TContents>();
+			MaxSize = maxSize;
+		}
+
+		#region Queue Methods
+
+		/// <summary>
+		/// Clears all items from the queue.
+		/// </summary>
+		public void Clear()
+		{
+			m_CollectionLock.Execute(() => m_Collection.Clear());
+		}
+
+		/// <summary>
+		/// Appends the item to the queue, trims old items that exceed max length.
+		/// </summary>
+		/// <param name="item"></param>
+		[PublicAPI]
+		public void Enqueue(TContents item)
+		{
+			m_CollectionLock.Execute(() => m_Collection.AddLast(item));
+			Trim();
+		}
+
+		/// <summary>
+		/// Removes the oldest item from the queue.
+		/// </summary>
+		/// <returns></returns>
+		[PublicAPI]
+		public TContents Dequeue()
+		{
+			m_CollectionLock.Enter();
+
+			try
+			{
+				TContents output = m_Collection.First.Value;
+				m_Collection.RemoveFirst();
+				return output;
+			}
+			finally
+			{
+				m_CollectionLock.Leave();
+			}
+		}
+
+		/// <summary>
+		/// Returns the oldest item in the queue.
+		/// </summary>
+		/// <returns></returns>
+		[PublicAPI]
+		public TContents Peek()
+		{
+			return m_CollectionLock.Execute(() => m_Collection.First.Value);
+		}
+
+		#endregion
+
+		#region Implemented Methods
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return GetEnumerator();
+		}
+
+		public IEnumerator<TContents> GetEnumerator()
+		{
+			return m_CollectionLock.Execute(() => m_Collection.ToList().GetEnumerator());
+		}
+
+		void ICollection.CopyTo(Array myArr, int index)
+		{
+			m_CollectionLock.Enter();
+
+			try
+			{
+				foreach (TContents item in m_Collection)
+				{
+					myArr.SetValue(item, index);
+					index++;
+				}
+			}
+			finally
+			{
+				m_CollectionLock.Leave();
+			}
+		}
+
+		#endregion
+
+		#region Private Methods
+
+		/// <summary>
+		/// Removes items that fall outside of the max size.
+		/// </summary>
+		private void Trim()
+		{
+			m_CollectionLock.Enter();
+
+			try
+			{
+				while (Count > MaxSize)
+					m_Collection.RemoveFirst();
+			}
+			finally
+			{
+				m_CollectionLock.Leave();
+			}
+		}
+
+		#endregion
+	}
+}