Creating a Weak List

using System;
using System.Collections;
using System.Collections.Generic;
using Pfz.Caching;
using Pfz.Threading;

namespace Pfz.Collections
{
	/// <summary>
	/// This class is responsible for distributing a single enumerator
	/// among many enumerator readers, considering such readers can
	/// "loose" some of the items.
	/// This is useful for senting, for example, web-cam frames. A high-speed
	/// client can receive all frames, while a slow client can receive frame
	/// 1, then frame 6, frame 12... but will still receive the "most recent"
	/// frames.
	/// You can inherit this class the the MultiClientEnumerator themselves
	/// if you must only send the difference between frames.
	/// </summary>
	/// <typeparam name="T">
	/// The type of the item that the original enumerator returns.
	/// </typeparam>
	public class EnumeratorDistributor<T>:
		ThreadSafeExceptionAwareDisposable
	where
		T: class
	{
		internal HashSet<EnumeratorDistributorClient<T>> fClientEnumerators = new HashSet<EnumeratorDistributorClient<T>>();
	
		/// <summary>
		/// Creates a new Distributor over the given real enumerator.
		/// </summary>
		public EnumeratorDistributor(IFastEnumerator<T> baseEnumerator)
		{
			if (baseEnumerator == null)
				throw new ArgumentNullException("baseEnumerator");
			
			GCUtils.Collected += p_Collected;
			BaseEnumerator = baseEnumerator;
			
			UnlimitedThreadPool.Run(p_KeepReading);
		}
		
		/// <summary>
		/// Disposes the base enumerator and the clients actually connected.
		/// </summary>
		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				GCUtils.Collected -= p_Collected;
			
				var baseEnumerator = BaseEnumerator;
				if (baseEnumerator != null)
				{
					BaseEnumerator = null;
					baseEnumerator.Dispose();
				}
				
				fActualValue = null;
				
				var clients = fClientEnumerators;
				if(clients != null)
				{
					fClientEnumerators = null;

					// the normal lock can be used here, as our dispose is unabortable.
					lock(DisposeLock)
						foreach(var client in clients)
							client.Dispose();
				}
				
				var disposedEvent = Disposed;
				if (disposedEvent != null)
					disposedEvent(this, EventArgs.Empty);
			}
			
			base.Dispose(disposing);
		}
		private void p_Collected()
		{
			var clients = fClientEnumerators;
			if (clients == null)
			{
				GCUtils.Collected -= p_Collected;
				return;
			}
			
			AbortSafe.UnabortableLock
			(
				clients,
				delegate
				{
					// the if is here because there is a bug with trimexcess in empty hashsets, 
					// as the next foreach will throw an exception. 
					// This bug is already reported and should be corrected in future versions.
					if (clients.Count > 0) 
						clients.TrimExcess();
				}
			);
		}
		
		/// <summary>
		/// Gets the BaseEnumerator used by this distributor.
		/// </summary>
		public IFastEnumerator<T> BaseEnumerator { get; private set; }
		
		/// <summary>
		/// Called when this object is disposed.
		/// </summary>
		public event EventHandler Disposed;
		
		private volatile T fActualValue;
		
		/// <summary>
		/// Gets the Actual value without waiting.
		/// </summary>
		public T ActualValue
		{
			get
			{
				return fActualValue;
			}
		}
		
		private void p_KeepReading()
		{
			try
			{
				var baseEnumerator = BaseEnumerator;
				while(true)
				{
					if (WasDisposed)
						return;
					
					var actualValue = baseEnumerator.GetNext();
					fActualValue = actualValue;
					
					AbortSafe.Lock
					(
						DisposeLock,
						delegate
						{
							foreach(var client in fClientEnumerators)
								client.fEvent.Set();
						}
					);
							
					if (actualValue == null)
					{
						Dispose();
						return;
					}
				}
			}
			catch(Exception exception)
			{
				if (!WasDisposed)
					Dispose(exception);
			}
		}
		
		/// <summary>
		/// Creates a client for this enumerator.
		/// Inheritors can initialize additional information before returning 
		/// the enumerator client to you.
		/// </summary>
		public virtual EnumeratorDistributorClient<T> CreateClient()
		{
			return new EnumeratorDistributorClient<T>(this);
		}
	}
}