RecyclableSortedList added

Recyclable.Collections/Recyclable.Collections.csproj

@@ -15,10 +15,17 @@
 		<Description>Recyclable.Collections project is an open source framework for operating dynamic lists at performance close to raw arrays. It aims at providing high performance with minimal memory footprint. It implements IList&lt;T&gt;'s interface and is targeted as direct replacements of List&lt;T&gt;, SortableList&lt;T&gt;, PriorityQueue&lt;T&gt; and similar.
 		
 		The project &amp; source code is free for educational, open-source &amp; personal use.</Description>
+		<ProjectUrl>https://github.com/mlemanczyk/Recyclable.Collections</ProjectUrl>
+		<RepositoryUrl>https://github.com/mlemanczyk/Recyclable.Collections</RepositoryUrl>
+		<Copyright>Marek Lemańczyk 2023</Copyright>
+		<LicenseUrl>https://github.com/mlemanczyk/Recyclable.Collections</LicenseUrl>
+		<Readme>/README.md</Readme>
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <Compile Remove="RecyclableSortedList.cs" />
+	  <None Include="..\README.md" Link="README.md">
+	    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+	  </None>
 	</ItemGroup>
 
 </Project>

Recyclable.Collections/RecyclableList.cs

@@ -3,8 +3,6 @@ using System.Collections;
 
 namespace Recyclable.Collections
 {
-	public delegate void ItemAdded<T>(long index, T item);
-
 	public class RecyclableList<T> : IDisposable, IList<T>
 	{
 		private static readonly IEqualityComparer<T> _comparer = EqualityComparer<T>.Default;
@@ -13,9 +11,20 @@ namespace Recyclable.Collections
 		private readonly List<T[]> _arrays = new();
 		private bool _disposedValue;
 		private long _capacity;
+		protected uint _isUpdating;
 
-		private ItemAdded<T>? _itemAdded;
-		public event ItemAdded<T> ItemAdded { add => _itemAdded += value; remove => _itemAdded -= value; }
+		protected virtual void BlockUpdateEvent()
+		{
+			_isUpdating++;
+		}
+
+		protected virtual void UnblockUpdateEvent()
+		{
+			if (_isUpdating > 0)
+			{
+				_isUpdating--;
+			}
+		}
 
 		private static IEnumerable<T> EnumerateElements(List<T[]> arrays, int chunkSize, long totalCount)
 		{
@@ -58,9 +67,17 @@ namespace Recyclable.Collections
 		public RecyclableList(IEnumerable<T> source, int blockSize = RecyclableDefaults.BlockSize)
 		{
 			_blockSize = blockSize;
-			foreach (var item in source)
+			BlockUpdateEvent();
+			try
 			{
-				Add(item);
+				foreach (var item in source)
+				{
+					Add(item);
+				}
+			}
+			finally
+			{
+				UnblockUpdateEvent();
 			}
 		}
 
@@ -71,7 +88,10 @@ namespace Recyclable.Collections
 			set
 			{
 				_arrays[(int)(index / _blockSize)][index % _blockSize] = value;
-				_itemAdded?.Invoke(index, value);
+				if (!IsUpdating)
+				{
+					ListUpdated();
+				}
 			}
 		}
 
@@ -84,6 +104,7 @@ namespace Recyclable.Collections
 		public int Count => LongCount <= int.MaxValue ? (int)LongCount : int.MaxValue;
 		public long LongCount { get; protected set; }
 		public bool IsReadOnly { get; } = false;
+		public bool IsUpdating => _isUpdating > 0;
 
 		public void Add(T item)
 		{
@@ -95,15 +116,28 @@ namespace Recyclable.Collections
 			}
 
 			var newIndex = LongCount;
-			this[newIndex] = item;
-			// Don't merge these 2 lines, otherwise we'll have increased count
-			// before the item is actually added.
-			LongCount++;
-			_itemAdded?.Invoke(newIndex, item);
+			// We don't want this[newIndex] set to raise the update event, because
+			// the count would be wrong. We need to increase it, first.
+			BlockUpdateEvent();
+			try
+			{
+				this[newIndex] = item;
+				LongCount++;
+			}
+			finally
+			{
+				UnblockUpdateEvent();
+			}
+
+			if (!IsUpdating)
+			{
+				ListUpdated();
+			}
 		}
 
 		public void Clear()
 		{
+			BlockUpdateEvent();
 			try
 			{
 				for (var arrayIdx = 0; arrayIdx < _arrays.Count; arrayIdx++)
@@ -121,9 +155,16 @@ namespace Recyclable.Collections
 			}
 			finally
 			{
-				// Make sure the list is cleared so that we no longer use any of the arrays
-				LongCount = 0;
-				_arrays.Clear();
+				try
+				{
+					// Make sure the list is cleared so that we no longer use any of the arrays
+					LongCount = 0;
+					_arrays.Clear();
+				}
+				finally
+				{
+					UnblockUpdateEvent();
+				}
 			}
 		}
 
@@ -203,6 +244,10 @@ namespace Recyclable.Collections
 			}
 		}
 
+		protected virtual void ListUpdated()
+		{
+		}
+
 		// override finalizer only if 'Dispose(bool disposing)' has code to free unmanaged resources
 		// ~RecyclableList()
 		// {
@@ -216,5 +261,19 @@ namespace Recyclable.Collections
 			Dispose(disposing: true);
 			GC.SuppressFinalize(this);
 		}
+
+		public void BeginUpdate() => _isUpdating++;
+
+		public void EndUpdate()
+		{
+			if (_isUpdating > 0)
+			{
+				_isUpdating--;
+				if (_isUpdating == 0)
+				{
+					ListUpdated();
+				}
+			}
+		}
 	}
 }

Recyclable.Collections/RecyclableSortedList.cs

@@ -0,0 +1,43 @@
+namespace Recyclable.Collections
+{
+	public class RecyclableSortedList<TKey, TValue> : RecyclableList<(TKey Key, TValue Value)>
+		where TKey : notnull
+	{
+		private static readonly IComparer<(TKey, TValue)> _comparer = new FrequencyTupleComparer<TKey, TValue>();
+		private readonly SystemRandomNumberGenerator _randomNumberGenerator = new SystemRandomNumberGenerator();
+
+		protected override void ListUpdated()
+		{
+			base.ListUpdated();
+			QuickSort();
+		}
+
+		public RecyclableSortedList() : base()
+		{
+		}
+
+		public RecyclableSortedList(Dictionary<TKey, TValue> source, int blockSize = RecyclableDefaults.BlockSize)
+			: this(source.Select(x => (x.Key, x.Value)), blockSize)
+		{
+		}
+
+		public RecyclableSortedList(IEnumerable<(TKey Key, TValue Value)> source, int blockSize = RecyclableDefaults.BlockSize)
+			: base(source, blockSize)
+		{
+			QuickSort();
+		}
+
+		public void QuickSort()
+		{
+			_isUpdating++;
+			try
+			{
+				this.QuickSort(_comparer, _randomNumberGenerator);
+			}
+			finally
+			{
+				_isUpdating--;
+			}		
+		}
+	}
+}