Cleanup - Remove Graph library about firely-cql-sdk HOT 1 OPEN

public readonly record struct TraversalCallbacks<T>(
	Func<(T? Previous, T Current, T Next), bool>? AllowEnter = null,
	Action<(T? Previous, T Current)>? Enter = null,
	Action<(T? Previous, T Current)>? Exit = null)
{
	public static TraversalCallbacks<T> CreatePreventRevisits()
	{
		HashSet<T> visited = new();
		return new(AllowEnter: t => {
			var allow = visited.Add(t.Next);
			return allow;
		});
	}
}

public static class Traversal
{
	public static IEnumerable<T> DepthFirst<T>(
		T current,
		Func<T, IEnumerable<T>> getNextItems,
		TraversalCallbacks<T> callbacks = default,
		T? previous = default)
	{
		callbacks.Enter?.Invoke((previous, current));
		yield return current;

		foreach (var next in getNextItems(current))
		{
			if (callbacks.AllowEnter?.Invoke((previous, current, next)) ?? true)
			{
				foreach (var grandChild in DepthFirst(next, getNextItems, callbacks, current))
					yield return grandChild;
			}
		}		
		callbacks.Exit?.Invoke((previous, current));
	}

	public static IEnumerable<T> TopologicalSort<T>(
		T current,
		Func<T, IEnumerable<T>> getNextItems,
		TraversalCallbacks<T> callbacks = default,
		T? previous = default)
	{
		// Get the whole graph first (assuming everything is reachable from the current node)
		HashSet<T> unvisited = new();
		DepthFirst(current, getNextItems)
			.ForEach(n => unvisited.Add(n));

		HashSet<T> visited = new();
		Queue<T> results = new();
		TraversalCallbacks<T> callbacks2 =
			new(
				Enter: t =>
				{
					visited.Add(t.Current);
					unvisited.Remove(t.Current);
				},
				Exit: t =>
				{
					results.Enqueue(t.Current);
				},
				AllowEnter: t =>
				{
					var allow = !visited.Contains(t.Next);
					return allow;
				});

		while (unvisited.Count > 0)
			DepthFirst(unvisited.First(), getNextItems, callbacks2).ForEach(_ => {});

		return results;
	}
}

// TEST

	//A -> B
	//A -> D
	//A -> E
	//B -> C
	//C -> G
	//D -> G
	//E -> F
	//F -> D	
	string[] GetNext(string current) => current switch
	{
		"A" => ["B", "D", "E"],
		"B" => ["C"],
		"C" => ["G"],
		"D" => ["G"],
		"E" => ["F"],
		"F" => ["D"],
		_ => Array.Empty<string>(),
	};

	Assert.Equal<string>(
		["G", "C", "B", "D", "F", "E", "A"], 
		Traversal.TopologicalSort("A", GetNext));