Example of custom event handling (#327)

## Description of Changes
*Describe what has been changed, any new features or bug fixes*

## API

 - [ ] This is an API breaking change to the SDK

*If the API is breaking, please state below what will break*

## Requires SpacetimeDB PRs
*List any PRs here that are required for this SDK change to work*

## Testsuite
*If you would like to run the your SDK changes in this PR against a
specific SpacetimeDB branch, specify that here. This can be a branch
name or a link to a PR.*

SpacetimeDB branch name: master

## Testing
*Write instructions for a test that you performed for this PR*

- [ ] Describe a test for this PR that you have completed

---------

Co-authored-by: Alessandro Asoni <[email protected]>
Co-authored-by: James Gilles <[email protected]>

Author: 3 people

src/EventHandling.meta

@@ -0,0 +1,100 @@
+using System;
+
+namespace SpacetimeDB.EventHandling
+{
+    internal class AbstractEventHandler
+    {
+        private EventListeners<Action> Listeners { get; } = new();
+
+        public void Invoke()
+        {
+            for (var i = Listeners.Count - 1; i >= 0; i--)
+            {
+                Listeners[i]?.Invoke();
+            }
+        }
+
+        public void AddListener(Action listener) => Listeners.Add(listener);
+
+        public void RemoveListener(Action listener) => Listeners.Remove(listener);
+    }
+    internal class AbstractEventHandler<T>
+    {
+        private EventListeners<Action<T>> Listeners { get; } = new();
+
+        public void Invoke(T value)
+        {
+            for (var i = Listeners.Count - 1; i >= 0; i--)
+            {
+                Listeners[i]?.Invoke(value);
+            }
+        }
+
+        public void AddListener(Action<T> listener) => Listeners.Add(listener);
+        public void RemoveListener(Action<T> listener) => Listeners.Remove(listener);
+    }
+
+    internal class AbstractEventHandler<T1, T2>
+    {
+        private EventListeners<Action<T1, T2>> Listeners { get; } = new();
+
+        public void Invoke(T1 v1, T2 v2)
+        {
+            for (var i = Listeners.Count - 1; i >= 0; i--)
+            {
+                Listeners[i]?.Invoke(v1, v2);
+            }
+        }
+
+        public void AddListener(Action<T1, T2> listener) => Listeners.Add(listener);
+        public void RemoveListener(Action<T1, T2> listener) => Listeners.Remove(listener);
+    }
+
+    internal class AbstractEventHandler<T1, T2, T3>
+    {
+        private EventListeners<Action<T1, T2, T3>> Listeners { get; } = new();
+
+        public void Invoke(T1 v1, T2 v2, T3 v3)
+        {
+            for (var i = Listeners.Count - 1; i >= 0; i--)
+            {
+                Listeners[i]?.Invoke(v1, v2, v3);
+            }
+        }
+
+        public void AddListener(Action<T1, T2, T3> listener) => Listeners.Add(listener);
+        public void RemoveListener(Action<T1, T2, T3> listener) => Listeners.Remove(listener);
+    }
+
+    internal class AbstractEventHandler<T1, T2, T3, T4>
+    {
+        private EventListeners<Action<T1, T2, T3, T4>> Listeners { get; } = new();
+
+        public void Invoke(T1 v1, T2 v2, T3 v3, T4 v4)
+        {
+            for (var i = Listeners.Count - 1; i >= 0; i--)
+            {
+                Listeners[i]?.Invoke(v1, v2, v3, v4);
+            }
+        }
+
+        public void AddListener(Action<T1, T2, T3, T4> listener) => Listeners.Add(listener);
+        public void RemoveListener(Action<T1, T2, T3, T4> listener) => Listeners.Remove(listener);
+    }
+
+    internal class AbstractEventHandler<T1, T2, T3, T4, T5>
+    {
+        private EventListeners<Action<T1, T2, T3, T4, T5>> Listeners { get; } = new();
+
+        public void Invoke(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5)
+        {
+            for (var i = Listeners.Count - 1; i >= 0; i--)
+            {
+                Listeners[i]?.Invoke(v1, v2, v3, v4, v5);
+            }
+        }
+
+        public void AddListener(Action<T1, T2, T3, T4, T5> listener) => Listeners.Add(listener);
+        public void RemoveListener(Action<T1, T2, T3, T4, T5> listener) => Listeners.Remove(listener);
+    }
+}

src/EventHandling/AbstractEventHandler.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections.Generic;
+
+namespace SpacetimeDB.EventHandling
+{
+    internal class EventListeners<T> where T : Delegate
+    {
+        private List<T> List { get; }
+        private Dictionary<T, int> Indices { get; }
+
+        public int Count => List.Count;
+
+        public T this[int index] => List[index];
+
+        public EventListeners() : this(0) { }
+        public EventListeners(int initialSize)
+        {
+            List = new List<T>(initialSize);
+            Indices = new Dictionary<T, int>(initialSize);
+        }
+
+        public void Add(T listener)
+        {
+            if (listener == null || !Indices.TryAdd(listener, List.Count)) return;
+            List.Add(listener);
+        }
+
+        public void Remove(T listener)
+        {
+            if (listener == null || List.Count <= 0 || !Indices.Remove(listener, out var index)) return;
+            var lastListener = List[^1];
+            if (lastListener != listener)
+            {
+                Indices[lastListener] = index;
+            }
+
+            List.RemoveAtSwapBack(index);
+        }
+    }
+}

src/EventHandling/AbstractEventHandler.cs.meta

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+
+namespace SpacetimeDB.EventHandling
+{
+    internal static class ListExtensions
+    {
+        public static void RemoveAtSwapBack<T>(this List<T> list, int index)
+        {
+            if (list == null) throw new ArgumentNullException(nameof(list));
+
+            var lastIndex = list.Count - 1;
+
+            if (index < 0 || index > lastIndex) throw new ArgumentOutOfRangeException(nameof(index), "Index is out of range.");
+
+            if (index == lastIndex)
+            {
+                list.RemoveAt(index);
+                return;
+            }
+
+            list[index] = list[lastIndex];
+
+            list.RemoveAt(lastIndex);
+        }
+    }
+}

src/EventHandling/EventListeners.cs

@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using SpacetimeDB.BSATN;
 using SpacetimeDB.ClientApi;
+using SpacetimeDB.EventHandling;
 
 #nullable enable
 namespace SpacetimeDB
@@ -134,8 +135,18 @@ public RemoteTableHandle(IDbConnection conn) : base(conn) { }
         // I didn't do that because that delays the index updates until after the row is processed.
         // In theory, that shouldn't be the issue, but I didn't want to break it right before leaving :)
         //          - Ingvar
-        private event Action<Row>? OnInternalInsert;
-        private event Action<Row>? OnInternalDelete;
+        private AbstractEventHandler<Row> OnInternalInsertHandler { get; } = new();
+        private event Action<Row> OnInternalInsert
+        {
+            add => OnInternalInsertHandler.AddListener(value);
+            remove => OnInternalInsertHandler.RemoveListener(value);
+        }
+        private AbstractEventHandler<Row> OnInternalDeleteHandler { get; } = new();
+        private event Action<Row> OnInternalDelete
+        {
+            add => OnInternalDeleteHandler.AddListener(value);
+            remove => OnInternalDeleteHandler.RemoveListener(value);
+        }
 
         // These are implementations of the type-erased interface.
         object? IRemoteTableHandle.GetPrimaryKey(IStructuralReadWrite row) => GetPrimaryKey((Row)row);
@@ -177,12 +188,32 @@ private static IReadWrite<Row> Serializer
         IStructuralReadWrite IRemoteTableHandle.DecodeValue(BinaryReader reader) => Serializer.Read(reader);
 
         public delegate void RowEventHandler(EventContext context, Row row);
-        public event RowEventHandler? OnInsert;
-        public event RowEventHandler? OnDelete;
-        public event RowEventHandler? OnBeforeDelete;
+        private CustomRowEventHandler OnInsertHandler { get; } = new();
+        public event RowEventHandler OnInsert
+        {
+            add => OnInsertHandler.AddListener(value);
+            remove => OnInsertHandler.RemoveListener(value);
+        }
+        private CustomRowEventHandler OnDeleteHandler { get; } = new();
+        public event RowEventHandler OnDelete
+        {
+            add => OnDeleteHandler.AddListener(value);
+            remove => OnDeleteHandler.RemoveListener(value);
+        }
+        private CustomRowEventHandler OnBeforeDeleteHandler { get; } = new();
+        public event RowEventHandler OnBeforeDelete
+        {
+            add => OnBeforeDeleteHandler.AddListener(value);
+            remove => OnBeforeDeleteHandler.RemoveListener(value);
+        }
 
         public delegate void UpdateEventHandler(EventContext context, Row oldRow, Row newRow);
-        public event UpdateEventHandler? OnUpdate;
+        private CustomUpdateEventHandler OnUpdateHandler { get; } = new();
+        public event UpdateEventHandler OnUpdate
+        {
+            add => OnUpdateHandler.AddListener(value);
+            remove => OnUpdateHandler.RemoveListener(value);
+        }
 
         public int Count => (int)Entries.CountDistinct;
 
@@ -195,7 +226,7 @@ void InvokeInsert(IEventContext context, IStructuralReadWrite row)
         {
             try
             {
-                OnInsert?.Invoke((EventContext)context, (Row)row);
+                OnInsertHandler.Invoke((EventContext)context, (Row)row);
             }
             catch (Exception e)
             {
@@ -207,7 +238,7 @@ void InvokeDelete(IEventContext context, IStructuralReadWrite row)
         {
             try
             {
-                OnDelete?.Invoke((EventContext)context, (Row)row);
+                OnDeleteHandler.Invoke((EventContext)context, (Row)row);
             }
             catch (Exception e)
             {
@@ -219,7 +250,7 @@ void InvokeBeforeDelete(IEventContext context, IStructuralReadWrite row)
         {
             try
             {
-                OnBeforeDelete?.Invoke((EventContext)context, (Row)row);
+                OnBeforeDeleteHandler.Invoke((EventContext)context, (Row)row);
             }
             catch (Exception e)
             {
@@ -231,7 +262,7 @@ void InvokeUpdate(IEventContext context, IStructuralReadWrite oldRow, IStructura
         {
             try
             {
-                OnUpdate?.Invoke((EventContext)context, (Row)oldRow, (Row)newRow);
+                OnUpdateHandler.Invoke((EventContext)context, (Row)oldRow, (Row)newRow);
             }
             catch (Exception e)
             {
@@ -276,7 +307,7 @@ void IRemoteTableHandle.Apply(IEventContext context, MultiDictionaryDelta<object
             {
                 if (value is Row newRow)
                 {
-                    OnInternalInsert?.Invoke(newRow);
+                    OnInternalInsertHandler.Invoke(newRow);
                 }
                 else
                 {
@@ -287,7 +318,7 @@ void IRemoteTableHandle.Apply(IEventContext context, MultiDictionaryDelta<object
             {
                 if (oldValue is Row oldRow)
                 {
-                    OnInternalDelete?.Invoke((Row)oldValue);
+                    OnInternalDeleteHandler.Invoke(oldRow);
                 }
                 else
                 {
@@ -297,7 +328,7 @@ void IRemoteTableHandle.Apply(IEventContext context, MultiDictionaryDelta<object
 
                 if (newValue is Row newRow)
                 {
-                    OnInternalInsert?.Invoke(newRow);
+                    OnInternalInsertHandler.Invoke(newRow);
                 }
                 else
                 {
@@ -309,7 +340,7 @@ void IRemoteTableHandle.Apply(IEventContext context, MultiDictionaryDelta<object
             {
                 if (value is Row oldRow)
                 {
-                    OnInternalDelete?.Invoke(oldRow);
+                    OnInternalDeleteHandler.Invoke(oldRow);
                 }
             }
         }
@@ -333,6 +364,37 @@ void IRemoteTableHandle.PostApply(IEventContext context)
             wasRemoved.Clear();
 
         }
+
+        private class CustomRowEventHandler
+        {
+            private EventListeners<RowEventHandler> Listeners { get; } = new();
+
+            public void Invoke(EventContext ctx, Row row)
+            {
+                for (var i = Listeners.Count - 1; i >= 0; i--)
+                {
+                    Listeners[i]?.Invoke(ctx, row);
+                }
+            }
+
+            public void AddListener(RowEventHandler listener) => Listeners.Add(listener);
+            public void RemoveListener(RowEventHandler listener) => Listeners.Remove(listener);
+        }
+        private class CustomUpdateEventHandler
+        {
+            private EventListeners<UpdateEventHandler> Listeners { get; } = new();
+
+            public void Invoke(EventContext ctx, Row oldRow, Row newRow)
+            {
+                for (var i = Listeners.Count - 1; i >= 0; i--)
+                {
+                    Listeners[i]?.Invoke(ctx, oldRow, newRow);
+                }
+            }
+
+            public void AddListener(UpdateEventHandler listener) => Listeners.Add(listener);
+            public void RemoveListener(UpdateEventHandler listener) => Listeners.Remove(listener);
+        }
     }
 }
-#nullable disable
+#nullable disable