You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
89 lines
3.6 KiB
89 lines
3.6 KiB
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using IPA.Config;
|
|
using IPA.Logging;
|
|
using IPA.Utilities;
|
|
|
|
namespace IPA.Loader
|
|
{
|
|
/// <summary>
|
|
/// The type that handles value injecting into a plugin's Init.
|
|
/// </summary>
|
|
public static class PluginInitInjector
|
|
{
|
|
|
|
/// <summary>
|
|
/// A typed injector for a plugin's Init method. When registered, called for all associated types. If it returns null, the default for the type will be used.
|
|
/// </summary>
|
|
/// <param name="previous">the previous return value of the function, or <see langword="null"/> if never called for plugin.</param>
|
|
/// <param name="param">the <see cref="ParameterInfo"/> of the parameter being injected.</param>
|
|
/// <param name="meta">the <see cref="PluginLoader.PluginMetadata"/> for the plugin being loaded.</param>
|
|
/// <returns>the value to inject into that parameter.</returns>
|
|
public delegate object InjectParameter(object previous, ParameterInfo param, PluginLoader.PluginMetadata meta);
|
|
|
|
/// <summary>
|
|
/// Adds an injector to be used when calling future plugins' Init methods.
|
|
/// </summary>
|
|
/// <param name="type">the type of the parameter.</param>
|
|
/// <param name="injector">the function to call for injection.</param>
|
|
public static void AddInjector(Type type, InjectParameter injector)
|
|
{
|
|
injectors.Add(new Tuple<Type, InjectParameter>(type, injector));
|
|
}
|
|
|
|
private static readonly List<Tuple<Type, InjectParameter>> injectors = new List<Tuple<Type, InjectParameter>>
|
|
{
|
|
new Tuple<Type, InjectParameter>(typeof(Logger), (prev, param, meta) => prev ?? new StandardLogger(meta.Name)),
|
|
new Tuple<Type, InjectParameter>(typeof(IModPrefs), (prev, param, meta) => prev ?? new ModPrefs(meta)),
|
|
new Tuple<Type, InjectParameter>(typeof(IConfigProvider), (prev, param, meta) =>
|
|
{
|
|
if (prev != null) return prev;
|
|
var cfgProvider = Config.Config.GetProviderFor(meta.Name, param);
|
|
cfgProvider.Load();
|
|
return cfgProvider;
|
|
})
|
|
};
|
|
|
|
internal static void Inject(MethodInfo init, PluginLoader.PluginInfo info)
|
|
{
|
|
var instance = info.Plugin;
|
|
var meta = info.Metadata;
|
|
|
|
var initArgs = new List<object>();
|
|
var initParams = init.GetParameters();
|
|
|
|
Dictionary<Tuple<Type, InjectParameter>, object> previousValues =
|
|
new Dictionary<Tuple<Type, InjectParameter>, object>(injectors.Count);
|
|
|
|
foreach (var param in initParams)
|
|
{
|
|
var paramType = param.ParameterType;
|
|
|
|
var value = paramType.GetDefault();
|
|
foreach (var pair in injectors.Where(t => paramType.IsAssignableFrom(t.Item1)))
|
|
{
|
|
object prev = null;
|
|
if (previousValues.ContainsKey(pair))
|
|
prev = previousValues[pair];
|
|
|
|
var val = pair.Item2?.Invoke(prev, param, meta);
|
|
|
|
if (previousValues.ContainsKey(pair))
|
|
previousValues[pair] = val;
|
|
else
|
|
previousValues.Add(pair, val);
|
|
|
|
if (val == null) continue;
|
|
value = val;
|
|
break;
|
|
}
|
|
|
|
initArgs.Add(value);
|
|
}
|
|
|
|
init.Invoke(instance, initArgs.ToArray());
|
|
}
|
|
}
|
|
}
|