using System;
using System.Collections.Generic;
using System.Linq;
namespace Unity.VisualScripting
{
/// <summary>
/// Invokes a method or a constructor via reflection.
/// </summary>
public sealed class InvokeMember : MemberUnit
{
public InvokeMember() : base() { }
public InvokeMember(Member member) : base(member) { }
private bool useExpandedParameters;
/// <summary>
/// Whether the target should be output to allow for chaining.
/// </summary>
[Serialize]
[InspectableIf(nameof(supportsChaining))]
public bool chainable { get; set; }
[DoNotSerialize]
public bool supportsChaining => member.requiresTarget;
[DoNotSerialize]
[MemberFilter(Methods = true, Constructors = true)]
public Member invocation
{
get { return member; }
set { member = value; }
}
[DoNotSerialize]
[PortLabelHidden]
public ControlInput enter { get; private set; }
[DoNotSerialize]
public Dictionary<int, ValueInput> inputParameters { get; private set; }
/// <summary>
/// The target object used when setting the value.
/// </summary>
[DoNotSerialize]
[PortLabel("Target")]
[PortLabelHidden]
public ValueOutput targetOutput { get; private set; }
[DoNotSerialize]
[PortLabelHidden]
public ValueOutput result { get; private set; }
[DoNotSerialize]
public Dictionary<int, ValueOutput> outputParameters { get; private set; }
[DoNotSerialize]
[PortLabelHidden]
public ControlOutput exit { get; private set; }
[DoNotSerialize]
private int parameterCount;
[Serialize]
List<string> parameterNames;
public override bool HandleDependencies()
{
if (!base.HandleDependencies())
return false;
// Here we have a chance to do a bit of post processing after deserialization of this node has occured.
// In the past we did not serialize parameter names explicitly (only parameter types), however, if we have
// exactly the same number of defaults as parameters, we happen to know what the original parameter names were.
// Note there is one specific exception that must be handled carefully, the base class (MemberUnit) adds a
// default value for the "target" (aka. the "this" instance) of the invocation; this does not correspond to
// a real parameter member so it is excluded here when trying to reconstruct the missing parameter names.
if (parameterNames == null && member.parameterTypes.Length == defaultValues.Count(d => d.Key != nameof(target)))
{
// Note that we strip the "%" prefix from the parameter name in the default values (the "%" denotes that
// it is a parameter input)
parameterNames = defaultValues
.Where(d => d.Key != nameof(target))
.Select(defaultValue => defaultValue.Key.Substring(1))
.ToList();
}
return true;
}
protected override void Definition()
{
base.Definition();
inputParameters = new Dictionary<int, ValueInput>();
outputParameters = new Dictionary<int, ValueOutput>();
useExpandedParameters = true;
enter = ControlInput(nameof(enter), Enter);
exit = ControlOutput(nameof(exit));
Succession(enter, exit);
if (member.requiresTarget)
{
Requirement(target, enter);
}
if (supportsChaining && chainable)
{
targetOutput = ValueOutput(member.targetType, nameof(targetOutput));
Assignment(enter, targetOutput);
}
if (member.isGettable)
{
result = ValueOutput(member.type, nameof(result), Result);
if (member.requiresTarget)
{
Requirement(target, result);
}
}
var parameterInfos = member.GetParameterInfos().ToArray();
parameterCount = parameterInfos.Length;
bool needsParameterRemapping = false;
for (int parameterIndex = 0; parameterIndex < parameterCount; parameterIndex++)
{
var parameterInfo = parameterInfos[parameterIndex];
var parameterType = parameterInfo.UnderlyingParameterType();
if (!parameterInfo.HasOutModifier())
{
var inputParameterKey = "%" + parameterInfo.Name;
// Changes in parameter names are tolerated, use the old parameter naming for now and fix it later.
if (parameterNames != null && parameterNames[parameterIndex] != parameterInfo.Name)
{
inputParameterKey = "%" + parameterNames[parameterIndex];
needsParameterRemapping = true;
}
var inputParameter = ValueInput(parameterType, inputParameterKey);
inputParameters.Add(parameterIndex, inputParameter);
inputParameter.SetDefaultValue(parameterInfo.PseudoDefaultValue());
if (parameterInfo.AllowsNull())
{
inputParameter.AllowsNull();
}
Requirement(inputParameter, enter);
if (member.isGettable)
{
Requirement(inputParameter, result);
}
}
if (parameterInfo.ParameterType.IsByRef || parameterInfo.IsOut)
{
var outputParameterKey = "&" + parameterInfo.Name;
// Changes in parameter names are tolerated, use the old parameter naming for now and fix it later.
if (parameterNames != null && parameterNames[parameterIndex] != parameterInfo.Name)
{
outputParameterKey = "&" + parameterNames[parameterIndex];
needsParameterRemapping = true;
}
var outputParameter = ValueOutput(parameterType, outputParameterKey);
outputParameters.Add(parameterIndex, outputParameter);
Assignment(enter, outputParameter);
useExpandedParameters = false;
}
}
if (inputParameters.Count > 5)
{
useExpandedParameters = false;
}
if (parameterNames == null)
{
parameterNames = parameterInfos.Select(pInfo => pInfo.Name).ToList();
}
if (needsParameterRemapping)
{
// Note, this will have no effect unless we are in an Editor context. This is okay since for runtime
// purposes as it is actually fine to continue to use the old parameter names for the sake of setting up
// connections and default values. The only reason it is interesting to update to the new parameter
// names is for UI purposes.
UnityThread.EditorAsync(PostDeserializeRemapParameterNames);
}
}
private void PostDeserializeRemapParameterNames()
{
var parameterInfos = member.GetParameterInfos().ToArray();
// Sanity check
if (parameterNames?.Count != parameterInfos.Length)
return;
// Check if any of the method parameter names have changed (Note: handling of parameter type changes is not
// supported here, it is detected and handled elsewhere)
List<(ValueInput port, ValueOutput[] connectedSources)> renamedInputs = null;
List<(ValueOutput port, ValueInput[] connectedDestinations)> renamedOutputs = null;
List<(string name, object value)> renamedDefaults = null;
for (var i = 0; i < parameterInfos.Length; ++i)
{
var paramInfo = parameterInfos[i];
var oldParamName = parameterNames[i];
if (paramInfo.Name != oldParamName)
{
// Phase 1 of parameter renaming: disconnect any nodes connected to affected ports, remove affected
// ports from port definition, and remove any default values associated with affected ports.
if (valueInputs.TryGetValue("%" + oldParamName, out var oldInput))
{
var connectionSources = oldInput.validConnections.Select(con => con.source).ToArray();
foreach (var source in connectionSources)
source.DisconnectFromValid(oldInput);
valueInputs.Remove(oldInput);
if (renamedInputs == null)
renamedInputs = new List<(ValueInput, ValueOutput[])>(1);
renamedInputs.Add((new ValueInput("%" + paramInfo.Name, paramInfo.ParameterType), connectionSources));
if (defaultValues.TryGetValue(oldInput.key, out var defaultValue))
{
defaultValues.Remove(oldInput.key);
if (renamedDefaults == null)
renamedDefaults = new List<(string, object)>(1);
renamedDefaults.Add(("%" + paramInfo.Name, defaultValue));
}
}
else if (valueOutputs.TryGetValue("&" + oldParamName, out var oldOutput))
{
var connectionDestinations = oldOutput.validConnections.Select(con => con.destination).ToArray();
foreach (var destination in connectionDestinations)
destination.DisconnectFromValid(oldOutput);
valueOutputs.Remove(oldOutput);
if (renamedOutputs == null)
renamedOutputs = new List<(ValueOutput, ValueInput[])>(1);
renamedOutputs.Add((new ValueOutput("&" + paramInfo.Name, paramInfo.ParameterType), connectionDestinations));
}
parameterNames[i] = paramInfo.Name;
}
}
// Phase 2 of parameter renaming: add renamed version of affected ports back to the port definition, reconnect
// nodes back to those renamed ports, and redefine default values for those ports.
if (renamedInputs != null)
{
foreach (var renamedInput in renamedInputs)
{
valueInputs.Add(renamedInput.port);
foreach (var source in renamedInput.connectedSources)
source.ConnectToValid(renamedInput.port);
}
if (renamedDefaults != null)
{
foreach (var renamedDefault in renamedDefaults)
defaultValues[renamedDefault.name] = renamedDefault.value;
}
}
if (renamedOutputs != null)
{
foreach (var renamedOutput in renamedOutputs)
{
valueOutputs.Add(renamedOutput.port);
foreach (var destination in renamedOutput.connectedDestinations)
destination.ConnectToValid(renamedOutput.port);
}
}
if (renamedInputs != null || renamedOutputs != null)
{
Define();
}
}
protected override bool IsMemberValid(Member member)
{
return member.isInvocable;
}
private object Invoke(object target, Flow flow)
{
if (useExpandedParameters)
{
switch (inputParameters.Count)
{
case 0:
return member.Invoke(target);
case 1:
return member.Invoke(target,
flow.GetConvertedValue(inputParameters[0]));
case 2:
return member.Invoke(target,
flow.GetConvertedValue(inputParameters[0]),
flow.GetConvertedValue(inputParameters[1]));
case 3:
return member.Invoke(target,
flow.GetConvertedValue(inputParameters[0]),
flow.GetConvertedValue(inputParameters[1]),
flow.GetConvertedValue(inputParameters[2]));
case 4:
return member.Invoke(target,
flow.GetConvertedValue(inputParameters[0]),
flow.GetConvertedValue(inputParameters[1]),
flow.GetConvertedValue(inputParameters[2]),
flow.GetConvertedValue(inputParameters[3]));
case 5:
return member.Invoke(target,
flow.GetConvertedValue(inputParameters[0]),
flow.GetConvertedValue(inputParameters[1]),
flow.GetConvertedValue(inputParameters[2]),
flow.GetConvertedValue(inputParameters[3]),
flow.GetConvertedValue(inputParameters[4]));
default:
throw new NotSupportedException();
}
}
else
{
var arguments = new object[parameterCount];
for (int parameterIndex = 0; parameterIndex < parameterCount; parameterIndex++)
{
if (inputParameters.TryGetValue(parameterIndex, out var inputParameter))
{
arguments[parameterIndex] = flow.GetConvertedValue(inputParameter);
}
}
var result = member.Invoke(target, arguments);
for (int parameterIndex = 0; parameterIndex < parameterCount; parameterIndex++)
{
if (outputParameters.TryGetValue(parameterIndex, out var outputParameter))
{
flow.SetValue(outputParameter, arguments[parameterIndex]);
}
}
return result;
}
}
private object GetAndChainTarget(Flow flow)
{
if (member.requiresTarget)
{
var target = flow.GetValue(this.target, member.targetType);
if (supportsChaining && chainable)
{
flow.SetValue(targetOutput, target);
}
return target;
}
return null;
}
private object Result(Flow flow)
{
var target = GetAndChainTarget(flow);
return Invoke(target, flow);
}
private ControlOutput Enter(Flow flow)
{
var target = GetAndChainTarget(flow);
var result = Invoke(target, flow);
if (this.result != null)
{
flow.SetValue(this.result, result);
}
return exit;
}
#region Analytics
public override AnalyticsIdentifier GetAnalyticsIdentifier()
{
const int maxNumParameters = 5;
var s = $"{member.targetType.FullName}.{member.name}";
if (member.parameterTypes != null)
{
s += "(";
for (var i = 0; i < member.parameterTypes.Length; ++i)
{
if (i >= maxNumParameters)
{
s += $"->{i}";
break;
}
s += member.parameterTypes[i].FullName;
if (i < member.parameterTypes.Length - 1)
s += ", ";
}
s += ")";
}
var aid = new AnalyticsIdentifier
{
Identifier = s,
Namespace = member.targetType.Namespace
};
aid.Hashcode = aid.Identifier.GetHashCode();
return aid;
}
#endregion
}
}