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);