public override ILuaMultiValue Invoke(ILuaValue self, bool memberCall, int overload, ILuaMultiValue args)
{
if (overload >= 0)
{
throw new NotSupportedException(string.Format(Resources.CannotUseOverload, "LuaType"));
}
if (args == null)
{
args = new LuaMultiValue();
}
Type t = Type;
if (Helpers.GetCompatibleMethod(
t.GetConstructors()
.Where(c => c.GetCustomAttributes(typeof(LuaIgnoreAttribute), true).Length == 0)
.Select(c => Tuple.Create(c, (object)null)),
args, out ConstructorInfo method, out _))
{
object value = method.Invoke(Helpers.ConvertForArgs(args, method));
return(LuaMultiValue.CreateMultiValueFromObj(value));
}
throw new InvalidOperationException(string.Format(Resources.CannotCall, "LuaType"));
}
/// <summary>
/// Provides the implementation for operations that invoke an object. Classes
/// derived from the System.Dynamic.DynamicObject class can override this method
/// to specify dynamic behavior for operations such as invoking an object or
/// a delegate.
/// </summary>
/// <param name="binder">Provides information about the invoke operation.</param>
/// <param name="args">The arguments that are passed to the object during the invoke operation.
/// For example, for the sampleObject(100) operation, where sampleObject is derived
/// from the System.Dynamic.DynamicObject class, args[0] is equal to 100.</param>
/// <param name="result">The result of the object invocation.</param>
/// <returns>true if the operation is successful; otherwise, false. If this method returns
/// false, the run-time binder of the language determines the behavior. (In most
/// cases, a language-specific run-time exception is thrown.</returns>
public override bool TryInvoke(InvokeBinder binder, object[] args, out object result)
{
var ret = InvokeInternal(LuaNil.Nil, false, -1,
LuaMultiValue.CreateMultiValueFromObj(args));
result = ret.GetValue();
return(true);
}
protected override ILuaMultiValue _invokeInternal(ILuaValue target, bool methodCall,
int overload, ILuaMultiValue args) {
if (methodCall) {
args = new LuaMultiValue(new[] { target }.Concat(args).ToArray());
}
return _invokeInternal(args);
}
protected override ILuaMultiValue _invokeInternal(ILuaValue self, bool methodCall, int overload,
ILuaMultiValue args)
{
MethodInfo method;
object target;
if (overload < 0)
{
if (!Helpers.GetCompatibleMethod(_methods, args, out method, out target))
{
throw new ArgumentException(
$"No overload of method '{Name}' could be found with specified parameters.");
}
}
else
{
Tuple <MethodInfo, object> temp;
if (!_methods.TryGetIndex(overload, out temp))
{
throw new InvalidOperationException(
$"There is not an overload for '{Name}' with the index of '{overload}'.");
}
if (!Helpers.GetCompatibleMethod(new[] { temp }, args, out method, out target))
{
throw new ArgumentException(
$"No overload of method '{Name}' could be found with specified parameters.");
}
}
// Invoke the selected method
object retObj;
object[] r_args = Helpers.ConvertForArgs(args, method);
retObj = Helpers.DynamicInvoke(method, target, r_args);
// Restore by-reference variables.
var min = Math.Min(method.GetParameters().Length, args.Count);
for (int i = 0; i < min; i++)
{
args[i] = LuaValueBase.CreateValue(r_args[i]);
}
if (retObj is ILuaMultiValue ret)
{
return(ret);
}
// Convert the return type and return
Type returnType = method.ReturnType;
if (method.GetCustomAttributes(typeof(MultipleReturnAttribute), true).Length > 0)
{
if (typeof(IEnumerable).IsAssignableFrom(returnType))
{
// TODO: Support restricted variables.
IEnumerable tempE = (IEnumerable)retObj;
return(LuaMultiValue.CreateMultiValueFromObj(tempE.Cast <object>().ToArray()));
}
else
{
throw new InvalidOperationException(
"Methods marked with MultipleReturnAttribute must return a type compatible with " +
"IEnumerable.");
}
}
else
{
return(LuaMultiValue.CreateMultiValueFromObj(retObj));
}
}
