public R_VAL ExecuteSet(RubyState state, object obj, CallbackArguments args) { var arg = args.RawGet(0, false); PropertyInfo.SetValue(obj, RubyState.ValueToObjectOfType(state, arg, DataTypePtr, PropertyInfo.PropertyType, PropertyInfo.PropertyType, false), null); return(R_VAL.NIL); }
public R_VAL ExecuteSet(RubyState state, object obj, CallbackArguments args) { var arg = args.RawGet(0, false); FieldInfo.SetValue(obj, RubyState.ValueToObjectOfType(state, arg, DataTypePtr, FieldInfo.FieldType, FieldInfo.FieldType, false)); return(R_VAL.NIL); }
/// <summary> /// Builds the argument list. /// </summary> /// <param name="state">The ruby state.</param> /// <param name="obj">The object.</param> /// <param name="args">The arguments.</param> /// <param name="outParams">Output: A list containing the indices of all "out" parameters, or null if no out parameters are specified.</param> /// <returns>The arguments, appropriately converted.</returns> protected virtual object[] BuildArgumentList(RubyState state, object obj, CallbackArguments args, out List <int> outParams) { ParameterDescriptor[] parameters = Parameters; object[] pars = new object[parameters.Length]; int j = args.IsMethodCall ? 1 : 0; outParams = null; for (int i = 0; i < pars.Length; i++) { // keep track of out and ref params if (parameters[i].Type.IsByRef) { if (outParams == null) { outParams = new List <int> (); } outParams.Add(i); } // if an ext method, we have an obj -> fill the first param if (ExtensionMethodType != null && obj != null && i == 0) { pars[i] = obj; continue; } else if (parameters[i].Type == typeof(CallbackArguments)) { pars[i] = args.SkipMethodCall(); } // else, ignore out params else if (parameters[i].IsOut) { pars[i] = null; } else if (i == parameters.Length - 1 && VarArgsArrayType != null) { List <R_VAL> extraArgs = new List <R_VAL> (); while (true) { var arg = args.RawGet(j, false); j += 1; if (!R_VAL.IsNil(arg)) { extraArgs.Add(arg); } else { break; } } // here we have to worry we already have an array.. damn. We only support this for userdata. // remains to be analyzed what's the correct behavior here. For example, let's take a params object[].. // given a single table parameter, should it use it as an array or as an object itself ? if (extraArgs.Count == 1) { R_VAL arg = extraArgs[0]; if (R_VAL.IsData(arg)) { // if ( Framework.Do.IsAssignableFrom ( VarArgsArrayType, arg.UserData.Object.GetType () ) ) { // pars[ i ] = RubyDLL.ValueToDataObject< object > ( state, arg, RubyState.DATA_TYPE_PTR ); pars[i] = RubyState.ValueToRefObject(state, arg, DataTypePtr); continue; // } } } // ok let's create an array, and loop Array vararg = Array.CreateInstance(VarArgsElementType, extraArgs.Count); for (int ii = 0; ii < extraArgs.Count; ii++) { vararg.SetValue(RubyState.ValueToObjectOfType(state, extraArgs[ii], DataTypePtr, VarArgsElementType, null, false), ii); } pars[i] = vararg; } // else, convert it else { var arg = args.RawGet(j, false); pars[i] = RubyState.ValueToObjectOfType(state, arg, DataTypePtr, parameters[i].Type, parameters[i].DefaultValue, parameters[i].HasDefaultValue); j += 1; } } return(pars); }