384 lines
14 KiB
C#
384 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Immutable;
|
|
using System.Linq;
|
|
using Barotrauma.Extensions;
|
|
using Barotrauma.LuaCs.Events;
|
|
using Barotrauma.LuaCs.Services.Compatibility;
|
|
using FluentResults;
|
|
using FluentResults.LuaCs;
|
|
using OneOf;
|
|
|
|
namespace Barotrauma.LuaCs.Services;
|
|
|
|
public class EventService : IEventService, IEventAssemblyContextUnloading
|
|
{
|
|
private readonly record struct TypeStringKey : IEqualityComparer<TypeStringKey>, IEquatable<TypeStringKey>
|
|
{
|
|
public Type Type { get; init; }
|
|
public string TypeName { get; init; }
|
|
public readonly int HashCode;
|
|
|
|
public TypeStringKey(Type type)
|
|
{
|
|
Type = type ?? throw new ArgumentNullException(nameof(type));
|
|
TypeName = type.Name;
|
|
HashCode = TypeName.GetHashCode();
|
|
}
|
|
|
|
public TypeStringKey(string typeName)
|
|
{
|
|
Type = null;
|
|
TypeName = typeName ?? throw new ArgumentNullException(nameof(typeName));
|
|
HashCode = TypeName.GetHashCode();
|
|
}
|
|
|
|
public bool Equals(TypeStringKey x, TypeStringKey y)
|
|
{
|
|
if (x.Type is not null && y.Type is not null)
|
|
return x.Type == y.Type;
|
|
return x.TypeName == y.TypeName;
|
|
}
|
|
|
|
public int GetHashCode(TypeStringKey obj)
|
|
{
|
|
return obj.HashCode;
|
|
}
|
|
|
|
public static implicit operator TypeStringKey(Type type) => new(type);
|
|
public static implicit operator TypeStringKey(string typeName) => new(typeName);
|
|
}
|
|
/// <summary>
|
|
/// <para>Contains subscriber delegates by event and identifier.</para>
|
|
/// Structure:<br/>
|
|
/// - Key: Type or String, TypeName == String Equality.<br/>
|
|
/// - Value: Dictionary<br/>
|
|
/// ---- Key: Either string identifier or subscriber instance pointer<br/>
|
|
/// ---- Value: Subscriber delegate<br/>
|
|
/// </summary>
|
|
private readonly Dictionary<TypeStringKey, Dictionary<OneOf<string, IEvent>, IEvent>> _subscriptions = new();
|
|
private readonly Dictionary<string, string> _eventTypeNameAliases = new();
|
|
private readonly Lazy<IPluginManagementService> _pluginManagementService;
|
|
private readonly Dictionary<TypeStringKey, Action<string, IDictionary<string, LuaCsFunc>>> _luaSubscriptionFactories = new();
|
|
/// <summary>
|
|
/// A collection of factories to produce subscribers from a single lua function handle. For legacy Add() API.
|
|
/// </summary>
|
|
private readonly Dictionary<TypeStringKey, Action<string, LuaCsFunc>> _luaLegacySubscriptionFactories = new();
|
|
/// <summary>
|
|
/// A collection of lua event subscribers from Add() that had neither a valid event name nor an event alias pointing to one.
|
|
/// Only actionable via Call().
|
|
/// </summary>
|
|
private readonly Dictionary<string, Dictionary<string, LuaCsFunc>> _luaOrphanSubscribers = new();
|
|
|
|
public EventService(Lazy<IPluginManagementService> pluginManagementService)
|
|
{
|
|
_pluginManagementService = pluginManagementService ?? throw new ArgumentNullException(nameof(pluginManagementService));
|
|
this.Subscribe<IEventAssemblyContextUnloading>(this);
|
|
}
|
|
|
|
public bool IsDisposed { get; private set; } = false;
|
|
|
|
#region Compatibility
|
|
|
|
[Obsolete("ACsMod is deprecated. Use ILuaEventService.Add() instead.")]
|
|
void ILuaCsHook.Add(string eventName, string identifier, LuaCsFunc callback, ACsMod mod = null)
|
|
{
|
|
Add(eventName, identifier, callback);
|
|
}
|
|
[Obsolete("ACsMod is deprecated. Use ILuaEventService.Add() instead.")]
|
|
void ILuaCsHook.Add(string eventName, LuaCsFunc callback, ACsMod mod = null)
|
|
{
|
|
Add(eventName, callback);
|
|
}
|
|
|
|
public bool Exists(string eventName, string identifier)
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
if (_subscriptions.ContainsKey(eventName) && _subscriptions[eventName].ContainsKey(identifier))
|
|
return true;
|
|
if (_luaOrphanSubscribers.ContainsKey(eventName))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
[Obsolete("Part of the legacy events API, only works for Lua-only custom events.")]
|
|
public T Call<T>(string eventName, params object[] args)
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
if (!_luaOrphanSubscribers.TryGetValue(eventName, out var dict))
|
|
return default;
|
|
T returnValue = default;
|
|
foreach (var sub in dict.Values)
|
|
{
|
|
try
|
|
{
|
|
var r = sub(args);
|
|
if (r != default)
|
|
returnValue = (T)r;
|
|
}
|
|
catch
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
return returnValue;
|
|
}
|
|
|
|
[Obsolete("Part of the legacy events API, only works for Lua-only custom events.")]
|
|
public object Call(string eventName, params object[] args) => Call<object>(eventName, args);
|
|
|
|
#endregion
|
|
|
|
public void Add(string eventName, string identifier, LuaCsFunc callback)
|
|
{
|
|
var eventKey = eventName;
|
|
if (_eventTypeNameAliases.TryGetValue(eventName, out var aliasType))
|
|
eventKey = aliasType;
|
|
if (_luaLegacySubscriptionFactories.TryGetValue(eventKey, out var factory))
|
|
{
|
|
factory(identifier, callback);
|
|
return;
|
|
}
|
|
_luaOrphanSubscribers.TryGetOrSet(eventName, () => new Dictionary<string, LuaCsFunc>())
|
|
.Add(identifier.IsNullOrWhiteSpace() ? string.Empty : identifier, callback);
|
|
}
|
|
|
|
public void Add(string eventName, LuaCsFunc callback)
|
|
{
|
|
Add(eventName, string.Empty, callback);
|
|
}
|
|
|
|
public void Remove(string eventName, string identifier)
|
|
{
|
|
if (_luaOrphanSubscribers.TryGetValue(eventName, out var dict))
|
|
dict.Remove(identifier);
|
|
if (_subscriptions.TryGetValue(eventName, out var dict2))
|
|
dict2.Remove(identifier);
|
|
}
|
|
|
|
public void PublishLuaEvent(string interfaceName, LuaCsFunc runner)
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
if (interfaceName.IsNullOrWhiteSpace())
|
|
return;
|
|
if (!_subscriptions.TryGetValue(interfaceName, out var dict))
|
|
return;
|
|
|
|
var type = _subscriptions
|
|
.Select(x => x.Key)
|
|
.FirstOrNull(x => x.Type?.Name == interfaceName)?.Type;
|
|
|
|
var errors = new Queue<IError>();
|
|
foreach (var eventSub in dict.Values)
|
|
{
|
|
try
|
|
{
|
|
runner(type is null ? eventSub : Convert.ChangeType(eventSub, type)); // cast if possible
|
|
}
|
|
catch
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
public FluentResults.Result RegisterSafeEvent<T>() where T : IEvent<T>
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
var type = typeof(T);
|
|
if (_luaSubscriptionFactories.ContainsKey(type))
|
|
return FluentResults.Result.Ok().WithReason(new Success($"The event {type.Name} is already registered."));
|
|
try
|
|
{
|
|
_luaSubscriptionFactories.Add(type, (ident, funcDict) =>
|
|
{
|
|
var runner = T.GetLuaRunner(funcDict);
|
|
var dict = _subscriptions.TryGetOrSet(type, () => new Dictionary<OneOf<string, IEvent>, IEvent>());
|
|
if (!ident.IsNullOrWhiteSpace())
|
|
dict[ident] = runner;
|
|
else
|
|
dict[runner] = runner;
|
|
});
|
|
return FluentResults.Result.Ok();
|
|
}
|
|
catch (NullReferenceException e)
|
|
{
|
|
return FluentResults.Result.Fail(new Error($"The lua runner for {type.Name} is not registered.")
|
|
.WithMetadata(MetadataType.ExceptionObject, this)
|
|
.WithMetadata(MetadataType.RootObject, type));
|
|
}
|
|
}
|
|
|
|
public FluentResults.Result UnregisterSafeEvent<T>() where T : IEvent<T>
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
_luaSubscriptionFactories.Remove(typeof(T));
|
|
if (!_subscriptions.TryGetValue(typeof(T), out var dict))
|
|
return FluentResults.Result.Ok();
|
|
dict.Values.Where(value => value.IsLuaRunner()).ToImmutableArray().ForEach(Unsubscribe);
|
|
return FluentResults.Result.Ok();
|
|
}
|
|
|
|
// lua subscribe
|
|
public void Subscribe(string interfaceName, string identifier, IDictionary<string, LuaCsFunc> callbacks)
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
if (_luaSubscriptionFactories.TryGetValue(interfaceName, out var subFactory))
|
|
subFactory(identifier, callbacks);
|
|
}
|
|
|
|
public FluentResults.Result SetLegacyLuaRunnerFactory<T>(Func<LuaCsFunc, T> runnerFactory) where T : IEvent<T>
|
|
{
|
|
var type = typeof(T);
|
|
if (!_luaSubscriptionFactories.TryGetValue(type, out var dict))
|
|
return FluentResults.Result.Fail(new Error($"Tried to add legacy lua factory for an event not registered for lua subscriptions."));
|
|
|
|
_luaLegacySubscriptionFactories[type] = (ident, func) =>
|
|
{
|
|
var runner = runnerFactory(func);
|
|
_subscriptions.TryGetOrSet(type, () => new Dictionary<OneOf<string, IEvent>, IEvent>())[ident] = runner;
|
|
};
|
|
return FluentResults.Result.Ok();
|
|
}
|
|
|
|
public void RemoveLegacyLuaRunnerFactory<T>() where T : IEvent<T>
|
|
{
|
|
_luaLegacySubscriptionFactories.Remove(typeof(T));
|
|
}
|
|
|
|
public void SetAliasToEvent<T>(string alias) where T : IEvent<T>
|
|
{
|
|
if (alias.IsNullOrWhiteSpace())
|
|
return;
|
|
_eventTypeNameAliases[alias] = typeof(T).Name;
|
|
}
|
|
|
|
public void RemoveEventAlias(string alias)
|
|
{
|
|
_eventTypeNameAliases.Remove(alias);
|
|
}
|
|
|
|
public void RemoveAllEventAliases<T>() where T : IEvent<T>
|
|
{
|
|
foreach (var keys in _eventTypeNameAliases
|
|
.Where(kvp => kvp.Value.IsNullOrWhiteSpace() || kvp.Value == typeof(T).Name)
|
|
.Select(kvp => kvp.Key).ToImmutableArray())
|
|
{
|
|
_eventTypeNameAliases.Remove(keys);
|
|
}
|
|
}
|
|
|
|
public FluentResults.Result Subscribe<T>(T subscriber) where T : IEvent<T>
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
var eventType = typeof(T);
|
|
var dict = _subscriptions.TryGetOrSet(eventType, () => new Dictionary<OneOf<string, IEvent>, IEvent>());
|
|
if (dict.ContainsKey(OneOf<string, IEvent>.FromT1(subscriber)))
|
|
{
|
|
return FluentResults.Result.Fail(
|
|
new Error($"The subscriber for {eventType.Name} is already registered to the event.")
|
|
.WithMetadata(MetadataType.ExceptionObject, this)
|
|
.WithMetadata(MetadataType.RootObject, subscriber));
|
|
}
|
|
dict[subscriber] = subscriber;
|
|
return FluentResults.Result.Ok();
|
|
}
|
|
|
|
public void Unsubscribe<T>(T subscriber) where T : IEvent
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
if (!_subscriptions.TryGetValue(typeof(T), out var dict))
|
|
return;
|
|
dict.Remove(OneOf<string, IEvent>.FromT1(subscriber));
|
|
}
|
|
|
|
public void ClearAllEventSubscribers<T>() where T : IEvent
|
|
{
|
|
_subscriptions.Remove(typeof(T));
|
|
if (typeof(IEventAssemblyContextUnloading) == typeof(T))
|
|
{
|
|
this.Subscribe<IEventAssemblyContextUnloading>(this);
|
|
}
|
|
}
|
|
public void ClearAllSubscribers()
|
|
{
|
|
_subscriptions.Clear();
|
|
this.Subscribe<IEventAssemblyContextUnloading>(this);
|
|
}
|
|
|
|
public FluentResults.Result PublishEvent<T>(Action<T> action) where T : IEvent<T>
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
var eventType = typeof(T);
|
|
if (!_subscriptions.TryGetValue(eventType, out var dict))
|
|
{
|
|
return FluentResults.Result.Fail(new Error($"The event {eventType.Name} is not registered.")
|
|
.WithMetadata(MetadataType.ExceptionObject, this));
|
|
}
|
|
|
|
var errors = new Queue<IError>();
|
|
foreach (var eventSub in dict.Values)
|
|
{
|
|
try
|
|
{
|
|
action((T)eventSub);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
#if DEBUG
|
|
throw; //make errors apparent
|
|
#endif
|
|
errors.Enqueue(new Error($"Error while executing runner for {eventType.Name} on type {eventSub.GetType().Name}.")
|
|
.WithMetadata(MetadataType.ExceptionObject, this)
|
|
.WithMetadata(MetadataType.RootObject, eventSub)
|
|
.WithMetadata(MetadataType.ExceptionDetails, e.Message)
|
|
.WithMetadata(MetadataType.StackTrace, e.StackTrace));
|
|
}
|
|
}
|
|
|
|
var result = errors.Count > 0 ? FluentResults.Result.Fail($"Errors while executing event type {eventType.Name}") : FluentResults.Result.Ok();
|
|
while (errors.Count > 0)
|
|
result = result.WithError(errors.Dequeue());
|
|
return result;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
IsDisposed = true;
|
|
_subscriptions.Clear();
|
|
_luaSubscriptionFactories.Clear();
|
|
_eventTypeNameAliases.Clear();
|
|
_luaLegacySubscriptionFactories.Clear();
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
public FluentResults.Result Reset()
|
|
{
|
|
((IService)this).CheckDisposed();
|
|
_subscriptions.Clear();
|
|
_luaSubscriptionFactories.Clear();
|
|
_eventTypeNameAliases.Clear();
|
|
_luaLegacySubscriptionFactories.Clear();
|
|
return FluentResults.Result.Ok();
|
|
}
|
|
|
|
public void OnAssemblyUnloading(WeakReference<IAssemblyLoaderService> loaderService)
|
|
{
|
|
if (!loaderService.TryGetTarget(out var loader))
|
|
return;
|
|
foreach (var assembly in loader.Assemblies)
|
|
{
|
|
var types = assembly.GetSafeTypes()
|
|
.Where(t => typeof(IEvent).IsAssignableFrom(t))
|
|
.ToImmutableArray();
|
|
if (!types.Any())
|
|
continue;
|
|
foreach (var type in types)
|
|
{
|
|
_subscriptions.Remove(type);
|
|
_luaSubscriptionFactories.Remove(type);
|
|
}
|
|
}
|
|
}
|
|
}
|