te

Unused/Decal.Adapter.IDQueue/FairRoundRobinScheduleQueue.cs

@@ -0,0 +1,298 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Runtime.InteropServices;
+using CustomCollections;
+
+namespace Decal.Adapter.IDQueue;
+
+/// <summary>
+/// A scheduler: callers request actions. Multiple callers can request the same action.
+/// -Each caller gets one action, then the other callers get a turn.
+/// -If a new caller arrives, it is given priority in the turns list.
+/// -Everytime a caller gets a turn, it selects its next available action in round-robin fashion.
+/// -If all of a caller's actions are unavailable when it is that caller's turn, its turn is lost and it must wait in line again.
+/// -If no caller can take a turn, the null action is returned.
+/// Thus if multiple callers request the same action, it will be tried more often
+/// since the attempt will occur during the turns of multiple callers.
+/// </summary>
+/// <typeparam name="CALLERTYPE"></typeparam>
+/// <typeparam name="ACTIONTYPE"></typeparam>
+[CLSCompliant(true)]
+[ClassInterface(ClassInterfaceType.None)]
+public abstract class FairRoundRobinScheduleQueue<CALLERTYPE, ACTIONTYPE>
+{
+	public class ActionRemovedEventArgs : EventArgs
+	{
+		private ACTIONTYPE mAction;
+
+		public ACTIONTYPE Action => mAction;
+
+		internal ActionRemovedEventArgs(ACTIONTYPE pAction)
+		{
+			mAction = pAction;
+		}
+	}
+
+	private class ActionInfo : IEquatable<ActionInfo>
+	{
+		public ACTIONTYPE Action;
+
+		public DateTime Expires;
+
+		public int TryCount;
+
+		public ActionInfo(ACTIONTYPE pAction, DateTime pExpires)
+		{
+			Action = pAction;
+			Expires = pExpires;
+		}
+
+		public bool IsExpired()
+		{
+			return Expires < DateTime.Now;
+		}
+
+		public bool Equals(ActionInfo other)
+		{
+			ref ACTIONTYPE action = ref Action;
+			object obj = other.Action;
+			return action.Equals(obj);
+		}
+
+		public override bool Equals(object obj)
+		{
+			return Equals(obj as ActionInfo);
+		}
+
+		public override int GetHashCode()
+		{
+			return Action.GetHashCode();
+		}
+	}
+
+	private HashedList<CALLERTYPE> Callers = new HashedList<CALLERTYPE>();
+
+	private Dictionary<ACTIONTYPE, ActionInfo> ActInfos = new Dictionary<ACTIONTYPE, ActionInfo>();
+
+	private Dictionary<CALLERTYPE, HashedList<ActionInfo>> CallerActions = new Dictionary<CALLERTYPE, HashedList<ActionInfo>>();
+
+	private Dictionary<ACTIONTYPE, HashedList<CALLERTYPE>> ActionCallers = new Dictionary<ACTIONTYPE, HashedList<CALLERTYPE>>();
+
+	private int MaximumTryCount;
+
+	private ACTIONTYPE NullAction;
+
+	public int CallerCount => Callers.Count;
+
+	public int ActionCount => ActInfos.Count;
+
+	public event EventHandler<ActionRemovedEventArgs> OnActionRemoved;
+
+	/// <summary>
+	///
+	/// </summary>
+	/// <param name="pMaximumTryCount">The most times an action can be attempted before it fails.</param>
+	/// <param name="pNullAction">An ACTIONTYPE to return when no action is available.</param>
+	protected FairRoundRobinScheduleQueue(int pMaximumTryCount, ACTIONTYPE pNullAction)
+	{
+		MaximumTryCount = pMaximumTryCount;
+		NullAction = pNullAction;
+	}
+
+	protected abstract bool IsActionValidNow(ACTIONTYPE action);
+
+	protected abstract bool IsActionPermanentlyInvalid(ACTIONTYPE action);
+
+	private void RotateQueue<T>(HashedList<T> q)
+	{
+		if (q.Count > 0)
+		{
+			T item = q[0];
+			q.RemoveAt(0);
+			q.Add(item);
+		}
+	}
+
+	public void ClearAll()
+	{
+		Callers.Clear();
+		ActInfos.Clear();
+		CallerActions.Clear();
+		ActionCallers.Clear();
+	}
+
+	public void DeleteAction(ACTIONTYPE action)
+	{
+		if (!ActionCallers.ContainsKey(action) || !ActInfos.ContainsKey(action))
+		{
+			return;
+		}
+		ActionInfo item = ActInfos[action];
+		ActInfos.Remove(action);
+		HashedList<CALLERTYPE> hashedList = ActionCallers[action];
+		ActionCallers.Remove(action);
+		foreach (CALLERTYPE item2 in hashedList)
+		{
+			CallerActions[item2].Remove(item);
+			if (CallerActions[item2].Count == 0)
+			{
+				CallerActions.Remove(item2);
+				Callers.Remove(item2);
+			}
+		}
+		if (this.OnActionRemoved != null)
+		{
+			this.OnActionRemoved(this, new ActionRemovedEventArgs(action));
+		}
+	}
+
+	public void DeleteCaller(CALLERTYPE caller)
+	{
+		Callers.Remove(caller);
+		if (!CallerActions.ContainsKey(caller))
+		{
+			return;
+		}
+		HashedList<ActionInfo> hashedList = CallerActions[caller];
+		CallerActions.Remove(caller);
+		HashedList<ActionInfo> hashedList2 = new HashedList<ActionInfo>();
+		foreach (ActionInfo item in hashedList)
+		{
+			if (ActionCallers.ContainsKey(item.Action))
+			{
+				ActionCallers[item.Action].Remove(caller);
+				if (ActionCallers[item.Action].Count == 0)
+				{
+					ActionCallers.Remove(item.Action);
+					ActInfos.Remove(item.Action);
+					hashedList2.Add(item);
+				}
+			}
+		}
+		if (this.OnActionRemoved == null)
+		{
+			return;
+		}
+		foreach (ActionInfo item2 in hashedList2)
+		{
+			this.OnActionRemoved(this, new ActionRemovedEventArgs(item2.Action));
+		}
+	}
+
+	public ReadOnlyCollection<ACTIONTYPE> GetActionsForCaller(CALLERTYPE caller)
+	{
+		List<ACTIONTYPE> list = new List<ACTIONTYPE>();
+		if (CallerActions.ContainsKey(caller))
+		{
+			foreach (ActionInfo item in CallerActions[caller])
+			{
+				list.Add(item.Action);
+			}
+		}
+		return list.AsReadOnly();
+	}
+
+	public ReadOnlyCollection<CALLERTYPE> GetCallersForAction(ACTIONTYPE action)
+	{
+		if (ActionCallers.ContainsKey(action))
+		{
+			return ActionCallers[action].AsReadOnly();
+		}
+		return new List<CALLERTYPE>().AsReadOnly();
+	}
+
+	public void Enqueue(CALLERTYPE caller, ACTIONTYPE action, DateTime expiration)
+	{
+		ActionInfo actionInfo;
+		if (ActInfos.ContainsKey(action))
+		{
+			actionInfo = ActInfos[action];
+			if (actionInfo.Expires < expiration)
+			{
+				actionInfo.Expires = expiration;
+			}
+			actionInfo.TryCount = 0;
+		}
+		else
+		{
+			actionInfo = new ActionInfo(action, expiration);
+			ActInfos[action] = actionInfo;
+		}
+		if (!CallerActions.ContainsKey(caller) || !CallerActions[caller].Contains(actionInfo))
+		{
+			if (!Callers.Contains(caller))
+			{
+				Callers.Insert(0, caller);
+			}
+			if (!CallerActions.ContainsKey(caller))
+			{
+				CallerActions.Add(caller, new HashedList<ActionInfo>());
+			}
+			CallerActions[caller].Add(actionInfo);
+			if (!ActionCallers.ContainsKey(action))
+			{
+				ActionCallers.Add(action, new HashedList<CALLERTYPE>());
+			}
+			ActionCallers[action].Add(caller);
+		}
+	}
+
+	public ACTIONTYPE GetNextAction(ref CALLERTYPE requester)
+	{
+		HashedList<ActionInfo> hashedList = new HashedList<ActionInfo>();
+		ACTIONTYPE result = NullAction;
+		for (int i = 0; i < Callers.Count; i++)
+		{
+			CALLERTYPE val = Callers[0];
+			HashedList<ActionInfo> hashedList2 = CallerActions[val];
+			bool flag = false;
+			for (int j = 0; j < hashedList2.Count; j++)
+			{
+				ActionInfo actionInfo = hashedList2[0];
+				if (hashedList.Contains(actionInfo))
+				{
+					RotateQueue(hashedList2);
+					continue;
+				}
+				if (actionInfo.IsExpired())
+				{
+					hashedList.Add(actionInfo);
+					RotateQueue(hashedList2);
+					continue;
+				}
+				if (IsActionPermanentlyInvalid(actionInfo.Action))
+				{
+					hashedList.Add(actionInfo);
+					RotateQueue(hashedList2);
+					continue;
+				}
+				if (!IsActionValidNow(actionInfo.Action))
+				{
+					RotateQueue(hashedList2);
+					continue;
+				}
+				flag = true;
+				result = actionInfo.Action;
+				requester = val;
+				RotateQueue(hashedList2);
+				actionInfo.TryCount++;
+				if (actionInfo.TryCount > MaximumTryCount)
+				{
+					hashedList.Add(actionInfo);
+				}
+				break;
+			}
+			RotateQueue(Callers);
+			if (flag)
+			{
+				break;
+			}
+		}
+		foreach (ActionInfo item in hashedList)
+		{
+			DeleteAction(item.Action);
+		}
+		return result;
+	}
+}