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.
260 lines
12 KiB
260 lines
12 KiB
#nullable enable
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using IPA.Logging;
|
|
using IPA.Utilities;
|
|
using IPA.AntiMalware;
|
|
#if NET4
|
|
using Expression = System.Linq.Expressions.Expression;
|
|
using ExpressionEx = System.Linq.Expressions.Expression;
|
|
#endif
|
|
#if NET3
|
|
using Net3_Proxy;
|
|
#endif
|
|
|
|
namespace IPA.Loader
|
|
{
|
|
/// <summary>
|
|
/// The type that handles value injecting into a plugin's initialization methods.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The default injectors and what they provide are shown in this table.
|
|
/// <list type="table">
|
|
/// <listheader>
|
|
/// <term>Parameter Type</term>
|
|
/// <description>Injected Value</description>
|
|
/// </listheader>
|
|
/// <item>
|
|
/// <term><see cref="Logger"/></term>
|
|
/// <description>A <see cref="StandardLogger"/> specialized for the plugin being injected</description>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term><see cref="PluginMetadata"/></term>
|
|
/// <description>The <see cref="PluginMetadata"/> of the plugin being injected</description>
|
|
/// </item>
|
|
/// <item>
|
|
/// <term><see cref="Config.Config"/></term>
|
|
/// <description>
|
|
/// <para>A <see cref="Config.Config"/> object for the plugin being injected.</para>
|
|
/// <para>
|
|
/// These parameters may have <see cref="Config.Config.NameAttribute"/> and <see cref="Config.Config.PreferAttribute"/> to control
|
|
/// how it is constructed.
|
|
/// </para>
|
|
/// </description>
|
|
/// </item>
|
|
/// </list>
|
|
/// For all of the default injectors, only one of each will be generated, and any later parameters will recieve the same value as the first one.
|
|
/// </remarks>
|
|
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="PluginMetadata"/> for the plugin being loaded.</param>
|
|
/// <returns>the value to inject into that parameter.</returns>
|
|
public delegate object? InjectParameter(object? previous, ParameterInfo param, PluginMetadata meta);
|
|
|
|
/// <summary>
|
|
/// A provider for parameter injectors to request injected values themselves.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Some injectors may look at attributes on the parameter to gain additional information about what it should provide.
|
|
/// If an injector wants to allow end users to affect the things it requests, it may pass the parameter it is currently
|
|
/// injecting for to this delegate along with a type override to select some other type.
|
|
/// </remarks>
|
|
/// <param name="forParam">the parameter that this is providing for.</param>
|
|
/// <param name="typeOverride">an optional override for the parameter type.</param>
|
|
/// <returns>the value that would otherwise be injected.</returns>
|
|
public delegate object? InjectedValueProvider(ParameterInfo forParam, Type? typeOverride = null);
|
|
|
|
/// <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="PluginMetadata"/> for the plugin being loaded.</param>
|
|
/// <param name="provider">an <see cref="InjectedValueProvider"/> to allow the injector to request injected values.</param>
|
|
/// <returns>the value to inject into that parameter.</returns>
|
|
public delegate object? InjectParameterNested(object? previous, ParameterInfo param, PluginMetadata meta, InjectedValueProvider provider);
|
|
|
|
/// <summary>
|
|
/// Invokes the provider with <paramref name="param"/> and <typeparamref name="T"/> and casts the result to <typeparamref name="T"/>.
|
|
/// </summary>
|
|
/// <typeparam name="T">the type of object to be injected</typeparam>
|
|
/// <param name="provider">the provider to invoke.</param>
|
|
/// <param name="param">the parameter to provide for</param>
|
|
/// <returns>the value requested, or <see langword="null"/>.</returns>
|
|
public static T? Inject<T>(this InjectedValueProvider provider, ParameterInfo param)
|
|
=> (T?)provider?.Invoke(param, typeof(T));
|
|
|
|
/// <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)
|
|
=> AddInjector(type, (pre, par, met, pro) => injector(pre, par, met));
|
|
|
|
/// <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, InjectParameterNested injector)
|
|
{
|
|
injectors.Add(new TypedInjector(type, injector));
|
|
}
|
|
|
|
private struct TypedInjector : IEquatable<TypedInjector>
|
|
{
|
|
public Type Type;
|
|
public InjectParameterNested Injector;
|
|
|
|
public TypedInjector(Type t, InjectParameterNested i)
|
|
{ Type = t; Injector = i; }
|
|
|
|
public object? Inject(object? prev, ParameterInfo info, PluginMetadata meta, InjectedValueProvider provider)
|
|
=> Injector(prev, info, meta, provider);
|
|
|
|
public bool Equals(TypedInjector other)
|
|
=> Type == other.Type && Injector == other.Injector;
|
|
|
|
public override bool Equals(object obj)
|
|
=> obj is TypedInjector i && Equals(i);
|
|
|
|
|
|
public override int GetHashCode()
|
|
=> Type.GetHashCode() ^ Injector.GetHashCode();
|
|
|
|
public static bool operator ==(TypedInjector a, TypedInjector b) => a.Equals(b);
|
|
public static bool operator !=(TypedInjector a, TypedInjector b) => !a.Equals(b);
|
|
}
|
|
|
|
private static readonly List<TypedInjector> injectors = new()
|
|
{
|
|
new TypedInjector(typeof(Logger), (prev, param, meta, _) => prev ?? new StandardLogger(meta.Name)),
|
|
new TypedInjector(typeof(PluginMetadata), (prev, param, meta, _) => prev ?? meta),
|
|
new TypedInjector(typeof(Config.Config), (prev, param, meta, _) => prev ?? Config.Config.GetConfigFor(meta.Name, param)),
|
|
new TypedInjector(typeof(IAntiMalware), (prev, param, meta, _) => prev ?? AntiMalwareEngine.Engine)
|
|
};
|
|
|
|
private static int? MatchPriority(Type target, Type source)
|
|
{
|
|
if (target == source) return int.MaxValue;
|
|
if (!target.IsAssignableFrom(source)) return null;
|
|
if (!target.IsInterface && !source.IsSubclassOf(target)) return int.MinValue;
|
|
|
|
int value = 0;
|
|
while (true)
|
|
{
|
|
if (source == null) return value;
|
|
if (target.IsInterface && source.GetInterfaces().Contains(target))
|
|
return value;
|
|
else if (target == source)
|
|
return value;
|
|
else
|
|
{
|
|
value--; // lower priority
|
|
source = source.BaseType;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static readonly MethodInfo InjectMethod = typeof(PluginInitInjector).GetMethod(nameof(Inject), BindingFlags.NonPublic | BindingFlags.Static);
|
|
internal static Expression InjectedCallExpr(ParameterInfo[] initParams, Expression meta, Expression persistVar, Func<IEnumerable<Expression>, Expression> exprGen)
|
|
{
|
|
var arr = ExpressionEx.Variable(typeof(object[]), "initArr");
|
|
return ExpressionEx.Block(new[] { arr },
|
|
ExpressionEx.Assign(arr, Expression.Call(InjectMethod, Expression.Constant(initParams), meta, persistVar)),
|
|
exprGen(initParams
|
|
.Select(p => p.ParameterType)
|
|
.Select((t, i) => (Expression)Expression.Convert(
|
|
Expression.ArrayIndex(arr, Expression.Constant(i)), t))));
|
|
}
|
|
|
|
private static object? InjectForParameter(
|
|
Dictionary<TypedInjector, object?> previousValues,
|
|
PluginMetadata meta,
|
|
ParameterInfo param,
|
|
Type paramType,
|
|
InjectedValueProvider provider)
|
|
{
|
|
var value = paramType.GetDefault();
|
|
|
|
var toUse = injectors
|
|
.Select(i => (inject: i, priority: MatchPriority(paramType, i.Type))) // check match priority, combine it
|
|
.NonNull(t => t.priority) // filter null priorities
|
|
.Select(t => (t.inject, priority: t.priority!.Value)) // remove nullable
|
|
.OrderByDescending(t => t.priority) // sort by value
|
|
.Select(t => t.inject); // remove priority value
|
|
|
|
// this tries injectors in order of closest match by type provided
|
|
foreach (var pair in toUse)
|
|
{
|
|
object? prev = null;
|
|
if (previousValues.ContainsKey(pair))
|
|
prev = previousValues[pair];
|
|
|
|
var val = pair.Inject(prev, param, meta, provider);
|
|
|
|
if (previousValues.ContainsKey(pair))
|
|
previousValues[pair] = val;
|
|
else
|
|
previousValues.Add(pair, val);
|
|
|
|
if (val == null) continue;
|
|
value = val;
|
|
break;
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
private class InjectedValueProviderWrapperImplementation
|
|
{
|
|
public Dictionary<TypedInjector, object?> PreviousValues { get; }
|
|
|
|
public PluginMetadata Meta { get; }
|
|
|
|
public InjectedValueProvider Provider { get; }
|
|
|
|
public InjectedValueProviderWrapperImplementation(PluginMetadata meta)
|
|
{
|
|
Meta = meta;
|
|
PreviousValues = new();
|
|
Provider = Inject;
|
|
}
|
|
|
|
private object? Inject(ParameterInfo param, Type? typeOverride = null)
|
|
=> InjectForParameter(PreviousValues, Meta, param, typeOverride ?? param.ParameterType, Provider);
|
|
}
|
|
|
|
internal static object?[] Inject(ParameterInfo[] initParams, PluginMetadata meta, ref object? persist)
|
|
{
|
|
var initArgs = new List<object?>();
|
|
|
|
var impl = persist as InjectedValueProviderWrapperImplementation;
|
|
if (impl == null || impl.Meta != meta)
|
|
{
|
|
impl = new(meta);
|
|
persist = impl;
|
|
}
|
|
|
|
foreach (var param in initParams)
|
|
{
|
|
var paramType = param.ParameterType;
|
|
|
|
var value = InjectForParameter(impl.PreviousValues, meta, param, paramType, impl.Provider);
|
|
|
|
initArgs.Add(value);
|
|
}
|
|
|
|
return initArgs.ToArray();
|
|
}
|
|
}
|
|
}
|