From 3bf3220beb0ab2734713f640b4bc0abacaeb03d1 Mon Sep 17 00:00:00 2001
From: Marc Hernandez <marcsh@gmail.com>
Date: Thu, 5 Feb 2026 18:27:56 -0800
Subject: [PATCH] Add filtering and timing

---
 SharpLib.csproj |  4 ++-
 logging/Log.cs  | 40 ++++++++++++++++++++++++
 util/Exec.cs    | 81 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 124 insertions(+), 1 deletion(-)
 create mode 100644 util/Exec.cs

diff --git a/SharpLib.csproj b/SharpLib.csproj
index 99cb4fe..d28658b 100644
--- a/SharpLib.csproj
+++ b/SharpLib.csproj
@@ -12,7 +12,9 @@
 		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
 		<LangVersion>14.0</LangVersion>
 		<Copyright>Copyright 2003..2025 Marc Hernandez</Copyright>
-		<Description>A base set of </Description>
+		<Description>A base set of functionality</Description>
+		<SatelliteResourceLanguages>en</SatelliteResourceLanguages>
+
 		<!--
 			I Want to turn this on, but cant yet.  Implementing nullability 1 file at a gime
 		<Nullable>enable</Nullable>
diff --git a/logging/Log.cs b/logging/Log.cs
index 439718a..e1f1a5f 100644
--- a/logging/Log.cs
+++ b/logging/Log.cs
@@ -529,11 +529,29 @@ static public class log
 
 	#endregion
 
+	public delegate bool FilterFn( LogEvent evt );
+
+
 
 	static object s_lock = new object();
 	static object s_lockTypeCallback = new object();
 	static ImmutableDictionary<LogType, Action<LogEvent>> s_callbacks = ImmutableDictionary<LogType, Action<LogEvent>>.Empty;
 
+	//static ConcurrentDictionary<string, List<FilterFn>> s_filters = new();
+
+	static public void addFilter( string name, FilterFn filter )
+	{
+		/*
+		s_filters.AddOrUpdate( name,
+			( k ) => new List<FilterFn> { filter },
+			( k, v ) => {
+				v.Add( filter );
+				return v;
+			} );
+		*/
+	}
+
+
 	[StackTraceHidden]
 	static public void addDirectCallback( LogType logType, Action<LogEvent> callback )
 	{
@@ -681,6 +699,27 @@ static public class log
 			// automatically finish when s_events.CompleteAdding() is called from another thread.
 			foreach( var evt in s_events.GetConsumingEnumerable() )
 			{
+				/*
+				// Apply filters
+				var cat = evt.Cat;
+				var blocked = false;
+				if( s_filters.TryGetValue( cat, out var filterList ) )
+				{
+					foreach( var filter in filterList )
+					{
+						if( !filter( evt ) )
+						{
+							blocked = true;
+							break;
+						}
+					}
+
+					if( blocked )
+					{
+						continue; // Skip this event
+					}
+				}
+				//*/
 				writeToAll( evt );
 			}
 		}
@@ -945,6 +984,7 @@ static public class log
 				{
 					var trimmedLine = line.Trim( (char)0 );
 					s_writer?.WriteLine( trimmedLine );
+					s_writer?.Flush();
 				}
 			}
 
diff --git a/util/Exec.cs b/util/Exec.cs
new file mode 100644
index 0000000..136e398
--- /dev/null
+++ b/util/Exec.cs
@@ -0,0 +1,81 @@
+
+
+
+using System.Diagnostics;
+
+namespace lib;
+
+public readonly ref struct Defer
+{
+	private readonly Action _onDispose;
+
+	public Defer( Action onDispose )
+	{
+		_onDispose = onDispose;
+	}
+
+	public void Dispose()
+	{
+		_onDispose?.Invoke();
+	}
+
+	public static Defer Do( Action action ) => new Defer( action );
+}
+
+
+	public readonly ref struct Timed
+	{
+		private readonly long _startTimestamp;
+		private readonly Action<TimeSpan> _onDispose;
+
+		public Timed( Action<TimeSpan> onDispose )
+		{
+			_onDispose = onDispose;
+			_startTimestamp = Stopwatch.GetTimestamp();
+		}
+
+		public void Dispose()
+		{
+			// Calculate elapsed ticks
+			long endTimestamp = Stopwatch.GetTimestamp();
+			long elapsedTicks = endTimestamp - _startTimestamp;
+
+			// Convert to TimeSpan based on system timer frequency
+			// (Standard formula for high-resolution timing)
+			double seconds = (double)elapsedTicks / Stopwatch.Frequency;
+			var elapsed = TimeSpan.FromSeconds( seconds );
+
+			_onDispose?.Invoke( elapsed );
+		}
+
+		// Optional: Allow peeking at the time without stopping
+		public TimeSpan Elapsed
+		{
+			get
+			{
+				long current = Stopwatch.GetTimestamp();
+				return TimeSpan.FromSeconds( (double)( current - _startTimestamp ) / Stopwatch.Frequency );
+			}
+		}
+
+	public static Timed Do( Action<TimeSpan> action ) => new Timed( action );
+
+
+}
+
+
+static public class Exec
+{
+	static public void RunIf( bool condition, Action func )
+	{
+		if( condition )
+			func();
+	}
+
+	static public T RunIf<T>( bool condition, Func<T> func, T ret = default! )
+	{
+		if( condition )
+			return func();
+		return ret;
+	}
+}