1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
|
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using StardewModdingAPI.Events;
using StardewModdingAPI.Internal;
namespace StardewModdingAPI.Framework.Events
{
/// <summary>An event wrapper which intercepts and logs errors in handler code.</summary>
/// <typeparam name="TEventArgs">The event arguments type.</typeparam>
internal class ManagedEvent<TEventArgs> : IManagedEvent
{
/*********
** Fields
*********/
/// <summary>The mod registry with which to identify mods.</summary>
protected readonly ModRegistry ModRegistry;
/// <summary>The underlying event handlers.</summary>
private readonly List<ManagedEventHandler<TEventArgs>> Handlers = new();
/// <summary>A cached snapshot of the <see cref="Handlers"/> sorted by event priority, or <c>null</c> to rebuild it next raise.</summary>
private ManagedEventHandler<TEventArgs>[]? CachedHandlers = Array.Empty<ManagedEventHandler<TEventArgs>>();
/// <summary>The total number of event handlers registered for this events, regardless of whether they're still registered.</summary>
private int RegistrationIndex;
/// <summary>Whether handlers were removed since the last raise.</summary>
private bool HasRemovedHandlers;
/// <summary>Whether any of the handlers have a custom priority.</summary>
private bool HasPriorities;
/*********
** Accessors
*********/
/// <inheritdoc />
public string EventName { get; }
/// <inheritdoc />
public bool HasListeners { get; private set; }
/*********
** Public methods
*********/
/// <summary>Construct an instance.</summary>
/// <param name="eventName">A human-readable name for the event.</param>
/// <param name="modRegistry">The mod registry with which to identify mods.</param>
public ManagedEvent(string eventName, ModRegistry modRegistry)
{
this.EventName = eventName;
this.ModRegistry = modRegistry;
}
/// <summary>Add an event handler.</summary>
/// <param name="handler">The event handler.</param>
/// <param name="mod">The mod which added the event handler.</param>
public void Add(EventHandler<TEventArgs> handler, IModMetadata mod)
{
lock (this.Handlers)
{
EventPriority priority = handler.Method.GetCustomAttribute<EventPriorityAttribute>()?.Priority ?? EventPriority.Normal;
var managedHandler = new ManagedEventHandler<TEventArgs>(handler, this.RegistrationIndex++, priority, mod);
this.Handlers.Add(managedHandler);
this.CachedHandlers = null;
this.HasListeners = true;
this.HasPriorities |= priority != EventPriority.Normal;
}
}
/// <summary>Remove an event handler.</summary>
/// <param name="handler">The event handler.</param>
public void Remove(EventHandler<TEventArgs> handler)
{
lock (this.Handlers)
{
// match C# events: if a handler is listed multiple times, remove the last one added
for (int i = this.Handlers.Count - 1; i >= 0; i--)
{
if (this.Handlers[i].Handler != handler)
continue;
this.Handlers.RemoveAt(i);
this.CachedHandlers = null;
this.HasListeners = this.Handlers.Count != 0;
this.HasRemovedHandlers = true;
break;
}
}
}
/// <summary>Raise the event and notify all handlers.</summary>
/// <param name="args">The event arguments to pass.</param>
public void Raise(TEventArgs args)
{
// skip if no handlers
if (this.Handlers.Count == 0)
return;
// raise event
foreach (ManagedEventHandler<TEventArgs> handler in this.GetHandlers())
{
Context.HeuristicModsRunningCode.Push(handler.SourceMod);
try
{
handler.Handler(null, args);
}
catch (Exception ex)
{
this.LogError(handler, ex);
}
finally
{
Context.HeuristicModsRunningCode.TryPop(out _);
}
}
}
/// <summary>Raise the event and notify all handlers.</summary>
/// <param name="invoke">Invoke an event handler. This receives the mod which registered the handler, and should invoke the callback with the event arguments to pass it.</param>
public void Raise(Action<IModMetadata, Action<TEventArgs>> invoke)
{
// skip if no handlers
if (this.Handlers.Count == 0)
return;
// raise event
foreach (ManagedEventHandler<TEventArgs> handler in this.GetHandlers())
{
Context.HeuristicModsRunningCode.Push(handler.SourceMod);
try
{
invoke(handler.SourceMod, args => handler.Handler(null, args));
}
catch (Exception ex)
{
this.LogError(handler, ex);
}
finally
{
Context.HeuristicModsRunningCode.TryPop(out _);
}
}
}
/*********
** Private methods
*********/
/// <summary>Log an exception from an event handler.</summary>
/// <param name="handler">The event handler instance.</param>
/// <param name="ex">The exception that was raised.</param>
private void LogError(ManagedEventHandler<TEventArgs> handler, Exception ex)
{
handler.SourceMod.LogAsMod($"This mod failed in the {this.EventName} event. Technical details: \n{ex.GetLogSummary()}", LogLevel.Error);
}
/// <summary>Get cached copy of the sorted handlers to invoke.</summary>
/// <remarks>This returns the handlers sorted by priority, and allows iterating the list even if a mod adds/removes handlers while handling it. This is debounced when requested to avoid repeatedly sorting when handlers are added/removed.</remarks>
private ManagedEventHandler<TEventArgs>[] GetHandlers()
{
ManagedEventHandler<TEventArgs>[]? handlers = this.CachedHandlers;
if (handlers == null)
{
lock (this.Handlers)
{
// recheck priorities
if (this.HasRemovedHandlers)
this.HasPriorities = this.Handlers.Any(p => p.Priority != EventPriority.Normal);
// sort by priority if needed
if (this.HasPriorities)
this.Handlers.Sort();
// update cache
this.CachedHandlers = handlers = this.Handlers.ToArray();
this.HasRemovedHandlers = false;
}
}
return handlers;
}
}
}
|
