private Expression BuildIndex(IIndexExpressionNode indexer)
{
if (indexer.Object == null)
{
throw BindingExceptionManager.UnexpectedExpressionNode(indexer);
}
var target = BuildExpression(indexer.Object);
if (target.Type.IsArray)
{
return(Expression.ArrayIndex(target, indexer.Arguments.Select(BuildExpression)));
}
var type = GetTargetType(ref target);
var targetData = new ArgumentData(indexer.Object, target, type, target == null);
var args = indexer
.Arguments
.ToArrayEx(node => new ArgumentData(node, node.NodeType == ExpressionNodeType.Lambda ? null : BuildExpression(node), null, false));
var exp = TryGenerateMethodCall(targetData.FindIndexer(args, target == null), targetData, args);
if (exp != null)
{
return(exp);
}
var arrayArgs = new Expression[args.Length];
for (int i = 0; i < args.Length; i++)
{
var data = args[i];
if (data.IsLambda || data.Expression == null)
{
throw BindingExceptionManager.InvalidBindingMember(type, ReflectionExtensions.IndexerName);
}
arrayArgs[i] = ExpressionReflectionManager.ConvertIfNeed(data.Expression, typeof(object), false);
}
return(Expression.Call(GetIndexValueDynamicMethod,
ExpressionReflectionManager.ConvertIfNeed(target, typeof(object), false),
Expression.NewArrayInit(typeof(object), arrayArgs), Expression.Constant(new MethodInvoker()), DataContextParameter));
}
public void SetSharedData(IDictionary <string, object> data)
{
Contract.NotNull(data, nameof(data));
CheckExistence();
using (var converter = new StringConverter())
{
var keys = new IntPtr[data.Count];
var values = new ArgumentData[data.Count];
var index = 0;
foreach (var element in data)
{
keys[index] = converter.StringToPointer(element.Key);
values[index] = ArgumentConverter.ConvertFromObject(element.Value);
index++;
}
Rage.Entity.Entity_SetVariables(NativePointer, keys, values, (ulong)data.Count);
}
}
private static ParameterInterpretation InterpretParameter(ParameterInfo parameter, object argument)
{
var argumentData = new ArgumentData(
argument,
parameter.Name,
parameter.ParameterType);
Attribute[] parameterAttributes = parameter.GetCustomAttributes(false).ToArray();
var constraints = GetParameterConstraints(parameterAttributes, argumentData).ToList();
var resolutionParameters = GetResolutionParameters(parameterAttributes, argumentData).ToList();
// by default, treat it like a type matching argument
if (!constraints.Any() && !resolutionParameters.Any())
{
resolutionParameters.Add(
TypeMatchingConstructorArgumentAttribute
.CreateTypeMatchingConstructorArgument(argumentData, false));
}
return new ParameterInterpretation(constraints, resolutionParameters);
}
private Expression BuildIndex(IIndexExpressionNode indexer)
{
if (indexer.Object == null)
{
throw BindingExceptionManager.UnexpectedExpressionNode(indexer);
}
var target = BuildExpression(indexer.Object);
if (target.Type.IsArray)
{
return(Expression.ArrayIndex(target, indexer.Arguments.Select(BuildExpression)));
}
var type = GetTargetType(ref target);
var targetData = new ArgumentData(indexer.Object, target, type);
var args = indexer
.Arguments
.ToArrayEx(node => new ArgumentData(node, node.NodeType == ExpressionNodeType.Lambda ? null : BuildExpression(node), null));
var method = targetData.FindIndexer(args, target == null);
return(GenerateMethodCall(method, targetData, args));
}
public void Call(IEnumerable <IPlayer> players, string eventName, IEnumerable <object> arguments)
{
Contract.NotNull(players, nameof(players));
Contract.NotEmpty(eventName, nameof(eventName));
Contract.NotNull(arguments, nameof(arguments));
var data = _plugin.ArgumentConverter.ConvertFromObjects(arguments);
var playerPointers = players.Select(x => x.NativePointer).ToArray();
if (playerPointers.Any() == false)
{
return;
}
using (var converter = new StringConverter())
{
var eventNamePointer = converter.StringToPointer(eventName);
Rage.PlayerPool.PlayerPool__CallFor(_nativePointer, playerPointers, (ulong)playerPointers.LongLength, eventNamePointer, data, (ulong)data.LongLength);
}
ArgumentData.Dispose(data);
}
public async Task CallAsync(IEnumerable <IPlayer> players, string eventName, IEnumerable <object> arguments)
{
Contract.NotNull(players, nameof(players));
Contract.NotEmpty(eventName, nameof(eventName));
Contract.NotNull(arguments, nameof(arguments));
var data = ArgumentConverter.ConvertFromObjects(arguments);
var playerPointers = players.Select(x => x.NativePointer).ToArray();
if (playerPointers.Any() == false)
{
return;
}
using (var converter = new StringConverter())
{
var eventNamePointer = converter.StringToPointer(eventName);
await TickScheduler.Instance
.Schedule(() => Rage.PlayerPool.PlayerPool__CallFor(_nativePointer, playerPointers, (ulong)playerPointers.Length, eventNamePointer, data, (ulong)data.Length));
}
ArgumentData.Dispose(data);
}
private Expression BuildMethodCall(IMethodCallExpressionNode methodCall)
{
if (methodCall.Target == null)
{
throw BindingExceptionManager.UnexpectedExpressionNode(methodCall);
}
var typeArgs = GetTypes(methodCall.TypeArgs);
var hasLambda = methodCall.Arguments
.OfType <ILambdaExpressionNode>()
.Any();
if (methodCall.Target.NodeType == ExpressionNodeType.DynamicMember)
{
if (hasLambda)
{
throw BindingExceptionManager.UnexpectedExpressionNode(methodCall);
}
var parameters = methodCall.Arguments
.Select(node => ExpressionReflectionManager.ConvertIfNeed(BuildExpression(node), typeof(object), false));
var arrayArg = Expression.NewArrayInit(typeof(object), parameters);
Type returnType = typeof(object);
var dynamicMethod = BindingServiceProvider
.ResourceResolver
.ResolveMethod(methodCall.Method, _dataContext, false);
if (dynamicMethod != null)
{
returnType = dynamicMethod.GetReturnType(arrayArg.Expressions.ToArrayEx(expression => expression.Type), typeArgs, _dataContext);
}
return(ExpressionReflectionManager.ConvertIfNeed(Expression.Call(_thisExpression, ProxyMethod, Expression.Constant(methodCall.Method),
DataContextParameter, Expression.Constant(typeArgs, typeof(IList <Type>)), arrayArg), returnType, false));
}
var target = BuildExpression(methodCall.Target);
var type = GetTargetType(ref target);
var targetData = new ArgumentData(methodCall.Target, target, type, target == null);
var args = methodCall
.Arguments
.ToArrayEx(node => new ArgumentData(node, node.NodeType == ExpressionNodeType.Lambda ? null : BuildExpression(node), null, false));
var types = new List <Type>(BindingServiceProvider.ResourceResolver.GetKnownTypes())
{
typeof(BindingReflectionExtensions)
};
var methods = targetData.FindMethod(methodCall.Method, typeArgs, args, types, target == null);
var exp = TryGenerateMethodCall(methods, targetData, args);
if (exp != null)
{
return(exp);
}
var arrayArgs = new Expression[args.Length];
for (int i = 0; i < args.Length; i++)
{
var data = args[i];
if (data.IsLambda || data.Expression == null)
{
throw BindingExceptionManager.InvalidBindingMember(type, methodCall.Method);
}
arrayArgs[i] = ExpressionReflectionManager.ConvertIfNeed(data.Expression, typeof(object), false);
}
if (target == null)
{
throw BindingExceptionManager.InvalidBindingMember(type, methodCall.Method);
}
return(Expression.Call(InvokeMemberDynamicMethod,
ExpressionReflectionManager.ConvertIfNeed(target, typeof(object), false),
Expression.Constant(methodCall.Method),
Expression.NewArrayInit(typeof(object), arrayArgs), Expression.Constant(typeArgs),
Expression.Constant(new MethodInvoker()), DataContextParameter));
}
protected override object OnCallMethod(object host, byte userFlags, ref ArgumentData arg, ushort serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
return(base.OnCallMethod(host, userFlags, ref arg, serialId, connect, ref routeInfo));
}
protected override void OnWriteArgument(ref NetCore.PkgWriter pkg, ref ArgumentData data)
{
pkg.SetUserFlags(2);
base.OnWriteArgument(ref pkg, ref data);
}
protected override object OnCallMethod(object host, byte userFlags, ref ArgumentData arg, ushort serialId, NetCore.NetConnection connect, ref NetCore.RPCRouter.RouteData routeInfo)
{
((RemoteServicesHelper)host).OnS2C_InstanceRender(userFlags, ref arg, serialId, connect, ref routeInfo);
return(null);
}
private static IList <MethodData> FindBestMethods(ArgumentData target, IList <MethodInfo> methods, IList <ArgumentData> arguments, Type[] typeArgs)
{
if (methods.Count == 0)
{
return(Empty.Array <MethodData>());
}
var candidates = new List <MethodData>();
for (int index = 0; index < methods.Count; index++)
{
try
{
var methodInfo = methods[index];
var args = GetMethodArgs(methodInfo.IsExtensionMethod(), target, arguments);
var methodData = TryInferMethod(methodInfo, args, typeArgs);
if (methodData == null)
{
continue;
}
var parameters = methodInfo.GetParameters();
var optionalCount = parameters.Count(info => info.HasDefaultValue());
var requiredCount = parameters.Length - optionalCount;
bool hasParams = false;
if (parameters.Length != 0)
{
hasParams = parameters[parameters.Length - 1].IsDefined(typeof(ParamArrayAttribute), true);
if (hasParams)
{
requiredCount -= 1;
}
}
if (requiredCount > args.Count)
{
continue;
}
if (parameters.Length < args.Count && !hasParams)
{
continue;
}
var count = parameters.Length > args.Count ? args.Count : parameters.Length;
bool valid = true;
for (int i = 0; i < count; i++)
{
var arg = args[i];
if (!IsCompatible(parameters[i].ParameterType, arg.Node))
{
valid = false;
break;
}
}
if (valid)
{
candidates.Add(methodData);
}
}
catch
{
;
}
}
return(candidates);
}
private static IEnumerable<IParameter> GetResolutionParameters(IEnumerable<Attribute> parameterAttributes, ArgumentData argument)
{
return parameterAttributes.OfType<IParameterAttribute>()
.SelectMany(x => x.RetrieveParameters(argument));
}
private static IEnumerable<Func<IBindingMetadata, bool>> GetParameterConstraints(IEnumerable<Attribute> parameterAttributes, ArgumentData argument)
{
return parameterAttributes.OfType<IParameterisedConstraintAttribute>()
.Select(x => x.CreateConstraint(argument));
}
internal static extern void Entity_SetVariable(IntPtr entity, IntPtr key, ref ArgumentData value);
