private static bool LinkDecoderAsArray <TEntity>(IDecoderDescriptor <TEntity> descriptor, BindingFlags bindings, Type type, object setter, IDictionary <Type, object> parents) { var constructor = MethodResolver .Create <Func <object> >(() => ConstructorGenerator.CreateConstructor <object>()) .SetGenericArguments(type) .Invoke(null); if (parents.TryGetValue(type, out var recurse)) { MethodResolver .Create <Func <IDecoderDescriptor <TEntity>, Func <object>, Setter <TEntity, IEnumerable <object> >, IDecoderDescriptor <object>, IDecoderDescriptor <object> > >((d, c, s, p) => d.HasElements(c, s, p)) .SetGenericArguments(type) .Invoke(descriptor, constructor, setter, recurse); return(true); } var itemDescriptor = MethodResolver .Create <Func <IDecoderDescriptor <TEntity>, Func <object>, Setter <TEntity, IEnumerable <object> >, IDecoderDescriptor <object> > >((d, c, s) => d.HasElements(c, s)) .SetGenericArguments(type) .Invoke(descriptor, constructor, setter); var result = MethodResolver .Create <Func <IDecoderDescriptor <object>, BindingFlags, Dictionary <Type, object>, bool> >((d, f, p) => Linker.LinkDecoder(d, f, p)) .SetGenericArguments(type) .Invoke(null, itemDescriptor, bindings, parents); return(result is bool success && success); }
private static MethodInfo GetMethod( Type clazz, string methodName, Type[] paramTypes, bool[] allFalse) { try { return MethodResolver.ResolveMethod(clazz, methodName, paramTypes, true, allFalse, allFalse); } catch (MethodResolverNoSuchMethodException) { var method = MethodResolver.ResolveExtensionMethod( clazz, methodName, paramTypes, true, allFalse, allFalse); if (method != null) { return method; } Log.Debug("Not resolved for class '" + clazz.Name + "' method '" + methodName + "'"); } catch (Exception) { Log.Debug("Not resolved for class '" + clazz.Name + "' method '" + methodName + "'"); } return null; }
public MethodInfo ResolveMethod( Type clazz, string methodName, Type[] paramTypes, bool[] allowEventBeanType) { try { return(MethodResolver.ResolveMethod( clazz, methodName, paramTypes, true, allowEventBeanType, allowEventBeanType)); } catch (MethodResolverNoSuchMethodException e) { var method = MethodResolver.ResolveExtensionMethod( clazz, methodName, paramTypes, true, allowEventBeanType, allowEventBeanType); if (method != null) { return(method); } throw Convert(clazz, methodName, paramTypes, e, true); } }
private Request BuildHttpRequest() { var methodName = method_selector.SelectedItem.ToString(); var method = MethodResolver.Resolve(methodName); var hostNameEndPos = Regex.Match(address_bar.Text, "/").Index; _hostName = address_bar.Text.Substring(0, hostNameEndPos); _resource = address_bar.Text.Substring(hostNameEndPos, address_bar.Text.Length - hostNameEndPos); var httpRequest = new Request(method, _hostName, _resource); if (Data != null) { httpRequest.Body = Data; httpRequest.AddHeader("Content-Length", Data.Length.ToString()); } else { httpRequest.AddHeader("Content-Length", "0"); } if (Credentials != null) { var authHeader = new AuthHeader(Credentials); httpRequest.AddHeader(authHeader); } if (Headers != null) { httpRequest.AddMultipleHeaders(Headers); } return(httpRequest); }
public MethodInfo ResolveMethod( String typeName, String methodName, Type[] paramTypes, bool[] allowEventBeanType, bool[] allowEventBeanCollType) { Type clazz; try { clazz = ResolveTypeInternal(typeName, false); } catch (TypeLoadException e) { throw new EngineImportException( "Could not load class by name '" + typeName + "', please check imports", e); } try { return(MethodResolver.ResolveMethod( clazz, methodName, paramTypes, false, allowEventBeanType, allowEventBeanCollType)); } catch (EngineNoSuchMethodException e) { throw Convert(clazz, methodName, paramTypes, e, false); } }
public void ResolveMethod_BaseMethodWithSameName() { var method = MethodResolver.ResolveMethod(typeof(DateTime), "ToString", "System.String ToString()"); Assert.That(method, Is.EqualTo(typeof(DateTime).GetMethod("ToString", Type.EmptyTypes))); Assert.That(method, Is.Not.EqualTo(typeof(object).GetMethod("ToString"))); }
private static bool LinkEncoderAsObject <TEntity>(IEncoderDescriptor <TEntity> descriptor, BindingFlags bindings, Type type, string name, object getter, IDictionary <Type, object> parents) { if (parents.TryGetValue(type, out var recurse)) { MethodResolver .Create <Func <IEncoderDescriptor <TEntity>, string, Func <TEntity, object>, IEncoderDescriptor <object>, IEncoderDescriptor <object> > >((d, n, a, p) => d.HasField(n, a, p)) .SetGenericArguments(type) .Invoke(descriptor, name, getter, recurse); return(true); } var fieldDescriptor = MethodResolver .Create <Func <IEncoderDescriptor <TEntity>, string, Func <TEntity, object>, IEncoderDescriptor <object> > >( (d, n, a) => d.HasField(n, a)) .SetGenericArguments(type) .Invoke(descriptor, name, getter); var result = MethodResolver .Create <Func <IEncoderDescriptor <object>, BindingFlags, Dictionary <Type, object>, bool> >((d, f, p) => Linker.LinkEncoder(d, f, p)) .SetGenericArguments(type) .Invoke(null, fieldDescriptor, bindings, parents); return(result is bool success && success); }
private static bool LinkDecoderAsObject <TEntity>(IDecoderDescriptor <TEntity> descriptor, BindingFlags bindings, Type type, string name, object setter, IDictionary <Type, object> parents) { var constructor = MethodResolver .Create <Func <object> >(() => ConstructorGenerator.CreateConstructor <object>()) .SetGenericArguments(type) .Invoke(null); if (parents.TryGetValue(type, out var parent)) { MethodResolver .Create <Func <IDecoderDescriptor <TEntity>, string, Func <object>, Setter <TEntity, object>, IDecoderDescriptor <object>, IDecoderDescriptor <object> > >((d, n, c, s, p) => d.HasField(n, c, s, p)) .SetGenericArguments(type) .Invoke(descriptor, name, constructor, setter, parent); return(true); } var fieldDescriptor = MethodResolver .Create <Func <IDecoderDescriptor <TEntity>, string, Func <object>, Setter <TEntity, object>, IDecoderDescriptor <object> > >((d, n, c, s) => d.HasField(n, c, s)) .SetGenericArguments(type) .Invoke(descriptor, name, constructor, setter); var result = MethodResolver .Create <Func <IDecoderDescriptor <object>, BindingFlags, Dictionary <Type, object>, bool> >((d, f, p) => Linker.LinkDecoder(d, f, p)) .SetGenericArguments(type) .Invoke(null, fieldDescriptor, bindings, parents); return(result is bool success && success); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection <RuntimeArgument> arguments = new Collection <RuntimeArgument>(); Type objectType = TypeHelper.ObjectType; if (this.TargetObject != null) { objectType = this.TargetObject.ArgumentType; } RuntimeArgument argument = new RuntimeArgument("TargetObject", objectType, ArgumentDirection.In); metadata.Bind(this.TargetObject, argument); arguments.Add(argument); this.resultArgument = new RuntimeArgument("Result", typeof(TResult), ArgumentDirection.Out); metadata.Bind(base.Result, this.resultArgument); arguments.Add(this.resultArgument); this.methodResolver = this.CreateMethodResolver(); this.methodResolver.DetermineMethodInfo(metadata, out this.methodExecutor); this.methodResolver.RegisterParameters(arguments); metadata.SetArgumentsCollection(arguments); this.methodResolver.Trace(); if (this.methodExecutor != null) { this.methodExecutor.Trace(this); } }
public MethodInfo ResolveMethod( Type clazz, String methodName, Type[] paramTypes, bool[] allowEventBeanType, bool[] allowEventBeanCollType) { try { return(MethodResolver.ResolveMethod( clazz, methodName, paramTypes, true, allowEventBeanType, allowEventBeanType)); } catch (EngineNoSuchMethodException e) { // Lets go looking for an extension method before throwing an exception var method = MethodResolver.ResolveExtensionMethod( clazz, methodName, paramTypes, true, allowEventBeanType, allowEventBeanType); if (method == null) { throw Convert(clazz, methodName, paramTypes, e, true); } return(method); } }
public ConstructorInfo ResolveCtor(Type clazz, Type[] paramTypes) { try { return(MethodResolver.ResolveCtor(clazz, paramTypes)); } catch (EngineNoSuchCtorException e) { throw Convert(clazz, paramTypes, e); } }
public CodegenExpression MakeCopyMethodClassScoped(CodegenClassScope classScope) { var factory = classScope.AddOrGetDefaultFieldSharable(EventBeanTypedEventFactoryCodegenField.INSTANCE); return NewInstance<BeanEventBeanConfiguredCopyMethod>( Cast( typeof(BeanEventType), EventTypeUtility.ResolveTypeCodegen(_beanEventType, EPStatementInitServicesConstants.REF)), factory, MethodResolver.ResolveMethodCodegenExactNonStatic(_copyMethod)); }
/// <summary> /// Parses a HTTP header from a HTTP/2 header collection /// </summary> /// <param name="headers">the header collection including pseudo headers</param> /// <param name="methodResolver">the method resolver</param> /// <returns>an optional used to determine if the invoker should listen for a payload</returns> public static HttpParserOptional ParseFrom(HttpHeaderCollection headers, MethodResolver <HttpMethod> methodResolver) { return(new HttpParserOptional { ExpectPayload = methodResolver.GetMethod(Encoding.UTF8.GetBytes(headers[":method"])).ExpectPayload || headers.ContainsKey("content-length") && headers["content-length"] != "0", Headers = headers, MethodResolver = methodResolver, Payload = null }); }
public override void Compile(CompileContext context) { string innerTypeName = "Repl_" + context.Type.Name; ILGenerator il = context.ILGenerator; TypeInfo newType = null; newType = Process.CompileNewProcessStart(context, innerTypeName); Process.Compile(context); Process.CompileNewProcessEnd(context); Label startLoop = il.DefineLabel(); il.MarkLabel(startLoop); LocalBuilder replCount = il.DeclareLocal(typeof(int)); //Give the replicated process the variables as they are at this point... foreach (string paramName in newType.ConstructorParameters) { il.Emit(OpCodes.Ldloc, context.Type.GetLocal(paramName)); } LocalBuilder loc = il.DeclareLocal(newType.Builder); il.Emit(OpCodes.Newobj, newType.Constructor); il.Emit(OpCodes.Stloc, loc); il.Emit(OpCodes.Ldloc, loc); //Set this process as the parent of the new proc, that allows it to activate this thread //again once it is past its first input action. il.Emit(OpCodes.Ldarg_0); //load the "this" pointer il.Emit(OpCodes.Call, MethodResolver.GetMethod(typeof(ProcessBase), "set_Parent")); //start the new instance of the replicated process il.Emit(OpCodes.Ldloc, loc); il.Emit(OpCodes.Call, MethodResolver.GetMethod(typeof(ProcessBase), "Run")); //Count how many we've emitted il.Emit(OpCodes.Ldloc, replCount); il.Emit(OpCodes.Ldc_I4_1); il.Emit(OpCodes.Add); il.Emit(OpCodes.Stloc, replCount); //Print that information. il.Emit(OpCodes.Ldstr, "Number of " + innerTypeName + " started: "); il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("Write", new Type[] { typeof(string) })); il.Emit(OpCodes.Ldloc, replCount); il.Emit(OpCodes.Call, typeof(System.Console).GetMethod("WriteLine", new Type[] { typeof(int) })); //Suspend ourselves, we will be woken up by the replicated process once it gets //past its first action... il.Emit(OpCodes.Call, typeof(Thread).GetMethod("get_CurrentThread")); il.Emit(OpCodes.Call, typeof(Thread).GetMethod("Suspend")); il.Emit(OpCodes.Br, startLoop); }
/// <summary> /// Create setter from any <see cref="IEnumerable{T}"/> elements to array target. /// </summary> /// <typeparam name="TElement">Element type</typeparam> /// <returns>Setter callback</returns> public static Setter <TElement[], IEnumerable <TElement> > CreateFromEnumerable <TElement>() { var arrayConverter = MethodResolver.Create <Func <IEnumerable <TElement>, TElement[]> >(e => e.ToArray()); var parameterTypes = new[] { typeof(TElement[]).MakeByRefType(), typeof(IEnumerable <TElement>) }; var method = new DynamicMethod(string.Empty, null, parameterTypes, typeof(TElement).Module, true); var generator = method.GetILGenerator(); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Call, arrayConverter.Method); generator.Emit(OpCodes.Stind_Ref); generator.Emit(OpCodes.Ret); return((Setter <TElement[], IEnumerable <TElement> >)method.CreateDelegate( typeof(Setter <TElement[], IEnumerable <TElement> >))); }
public override DataInputOutputSerdeForge ToForge() { var field = SerdeClass.GetField("INSTANCE"); if (field != null) { return new DataInputOutputSerdeForgeSingleton(SerdeClass); } try { MethodResolver.ResolveCtor(SerdeClass, new Type[0]); return new DataInputOutputSerdeForgeEmptyCtor(SerdeClass); } catch (MethodResolverNoSuchCtorException) { } throw new EPException("Serde class '" + SerdeClass.Name + "' does not have a singleton-style INSTANCE field or default constructor"); }
/// <summary> /// Given a field and a set of annotations, determines if we should use a custom parse adapter. /// </summary> /// <param name="services"></param> /// <param name="type"></param> /// <param name="fieldAnnotation"></param> /// <returns></returns> /// <exception cref="ExprValidationException"></exception> private JsonSerializationForgePair GetCustomSchemaAdapter( StatementCompileTimeServices services, Type type, JsonSchemaFieldAttribute fieldAnnotation) { Type clazz; try { clazz = services.ImportServiceCompileTime.ResolveClass(fieldAnnotation.Adapter, true, ExtensionClassEmpty.INSTANCE); } catch (ImportException e) { throw new ExprValidationException($"Failed to resolve Json schema field adapter class: {e.Message}", e); } if (clazz.FindGenericInterface(typeof(JsonFieldAdapterString <>)) == null) { throw new ExprValidationException( $"Json schema field adapter class does not implement interface '{typeof(JsonFieldAdapterString<>).CleanName()}"); } if (!clazz.HasDefaultConstructor()) { throw new ExprValidationException( $"Json schema field adapter class '{clazz.CleanName()}' does not have a default constructor"); } MethodInfo writeMethod; try { writeMethod = MethodResolver.ResolveMethod(clazz, "Parse", new Type[] { typeof(string) }, true, new bool[1], new bool[1]); } catch (MethodResolverNoSuchMethodException e) { throw new ExprValidationException( $"Failed to resolve write method of Json schema field adapter class: {e.Message}", e); } if (!TypeHelper.IsSubclassOrImplementsInterface(type, writeMethod.ReturnType)) { throw new ExprValidationException( $"Json schema field adapter class '{clazz.CleanName()}' mismatches the return type of the parse method, " + $"expected '{type.CleanName()}' but found '{writeMethod.ReturnType.CleanName()}'"); } return(new JsonSerializationForgePair( new JsonSerializerForgeProvidedStringAdapter(clazz), new JsonDeserializerForgeProvidedAdapter(clazz))); }
private HashSet <MethodInfo> DeserializeMethods(string collectionKey) { var methods = new HashSet <MethodInfo> (); var count = _serializationInfo.GetInt32(collectionKey + ".Count"); for (int i = 0; i < count; ++i) { var methodDeclaringType = Type.GetType(_serializationInfo.GetString(collectionKey + "[" + i + "].DeclaringType")); var name = _serializationInfo.GetString(collectionKey + "[" + i + "].Name"); var signature = _serializationInfo.GetString(collectionKey + "[" + i + "].Signature"); var method = MethodResolver.ResolveMethod(methodDeclaringType, name, signature); methods.Add(method); } return(methods); }
protected void EmitRunProcess(CompileContext context, TypeInfo procType, bool setGuidOnProc, LexicalInfo lexInfo, bool loadVariables) { if (context.Type == null || context.ILGenerator == null) { return; //Are at top level and so can't run the process } ILGenerator il = context.ILGenerator; if (loadVariables) { foreach (string paramName in procType.ConstructorParameters) { il.Emit(OpCodes.Ldloc, context.Type.GetLocal(paramName)); } } LocalBuilder loc = il.DeclareLocal(typeof(ProcessBase)); il.Emit(OpCodes.Newobj, procType.Constructor); il.Emit(OpCodes.Stloc, loc); il.Emit(OpCodes.Ldloc, loc); il.Emit(OpCodes.Ldarg_0); //load the "this" pointer //The current process doesn't have a restrict or relabel method, no reason for it //to continue living, set the parent process of the new proc as our own parent process if (!context.Type.IsPreProcessed && !context.Type.IsRestricted && !context.Type.MustLiveOn) { il.Emit(OpCodes.Call, MethodResolver.GetMethod(typeof(ProcessBase), "get_Parent")); } il.Emit(OpCodes.Call, MethodResolver.GetMethod(typeof(ProcessBase), "set_Parent")); if (setGuidOnProc) { il.Emit(OpCodes.Ldloc, loc); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Call, typeof(ProcessBase).GetMethod("get_SetID")); il.Emit(OpCodes.Call, typeof(ProcessBase).GetMethod("set_SetID")); } il.Emit(OpCodes.Ldloc, loc); if (context.Options.Debug && lexInfo != null) { //context.MarkSequencePoint(lexInfo); } il.Emit(OpCodes.Call, MethodResolver.GetMethod(typeof(ProcessBase), "Run")); }
/// <summary> /// Instantiates with the given <see cref="HttpHeaderCollection" />, payload, and method resolver. /// </summary> /// <param name="headers"> /// a collection of HTTP/2 headers with pseudo headers included (:method, :scheme, :authority, :path, /// and (optionally), :version /// </param> /// <param name="payload">the request payload (can be null)</param> /// <param name="methodResolver"> /// a method resolver to use to map the method name to a server-implemented /// <see cref="HttpMethod" /> /// </param> public HttpRequest(HttpHeaderCollection headers, byte[] payload, MethodResolver <HttpMethod> methodResolver) { if (payload != null) { InputStream = new MemoryStream(payload); } Method = methodResolver.GetMethod(Encoding.UTF8.GetBytes(headers[":method"].ToUpper())); RawMethod = headers[":method"]; Url = new Uri(headers[":scheme"] + "://" + headers[":authority"] + headers[":path"]); RawUrl = headers[":path"]; Headers = new HttpHeaderCollection(headers.Where <HeaderField>(x => !x.Name.StartsWith(":"))); InputStream = payload == null ? new MemoryStream() : new MemoryStream(payload); #pragma warning disable 618 Protocol = headers.ContainsKey(":version") ? headers[":version"] : null; #pragma warning restore 618 Cookies = new HttpCookieCollection(headers, true); }
public static void ValidateDTMStaticMethodAllowNull( Type inputType, DateTimeMethodMode mode, Type firstParameter, IList <ExprNode> paramExpressions) { if (mode == null) { if (inputType == firstParameter) { throw new ExprValidationException("Plugin datetime method does not provide a forge for input type " + inputType.CleanName()); } return; } if (!(mode is DateTimeMethodModeStaticMethod)) { throw new ExprValidationException("Unexpected plug-in datetime method mode implementation " + mode.GetType()); } var staticMethod = (DateTimeMethodModeStaticMethod)mode; var @params = new Type[paramExpressions.Count + 1]; @params[0] = firstParameter; for (var i = 0; i < paramExpressions.Count; i++) { @params[i + 1] = paramExpressions[i].Forge.EvaluationType; } try { MethodResolver.ResolveMethod( staticMethod.Clazz, staticMethod.MethodName, @params, false, new bool[@params.Length], new bool[@params.Length]); } catch (MethodResolverNoSuchMethodException ex) { throw new ExprValidationException("Failed to find static method for date-time method extension: " + ex.Message, ex); } }
public void MethodResolver_ResolvesCorrectly() { // Arrange var method = typeof(Counter).GetMethod(nameof(Counter.Increment)); var methodResolver = new MethodResolver(method); var counter = new Counter(); var context = new ResolveFieldContext() { Source = counter }; // Act var result = (int)methodResolver.Resolve(context); // Assert result.ShouldBe(1); counter.Value.ShouldBe(1); }
public void MethodResolver_SupportsEnumArguments() { // Arrange var method = typeof(Counter).GetMethod(nameof(Counter.HasParity)); var methodResolver = new MethodResolver(method, null, new [] { new QueryArgumentParameterInfo(method.GetParameters()[0]) }); var counter = new Counter { Value = 6 }; var context = new ResolveFieldContext { Source = counter, Arguments = new Dictionary <string, object> { { "parity", Parity.Even } } }; // Act var result = (bool)methodResolver.Resolve(context); // Assert result.ShouldBe(true); }
public MethodInfo ResolveMethodOverloadChecked( string className, string methodName, Type[] paramTypes, bool[] allowEventBeanType, bool[] allowEventBeanCollType, ExtensionClass extension) { Type clazz; try { clazz = ResolveClassInternal(className, false, false, extension); } catch (TypeLoadException e) { throw new ImportException( "Could not load class by name '" + className + "', please check imports", e); } try { return MethodResolver.ResolveMethod( clazz, methodName, paramTypes, false, allowEventBeanType, allowEventBeanCollType); } catch (MethodResolverNoSuchMethodException e) { var method = MethodResolver.ResolveExtensionMethod( clazz, methodName, paramTypes, true, allowEventBeanType, allowEventBeanType); if (method == null) { throw Convert(clazz, methodName, paramTypes, e, false); } return method; } }
public void FunctionsShouldHaveExpectedSignatures(INamespaceSymbol @namespace) { var knownOverloads = @namespace.TryGetNamespaceType() !.MethodResolver.GetKnownFunctions().Values .SelectMany(function => function.Overloads) .OrderBy(overload => overload.Name) .Select(Convert); var actual = JToken.FromObject(knownOverloads, DataSetSerialization.CreateSerializer()); var actualLocation = FileHelper.SaveResultFile(this.TestContext, $"{this.TestContext.TestName}_{@namespace.Name}.json", actual.ToString(Formatting.Indented)); var fileName = $"{@namespace.Name}.json"; var expectedStr = DataSets.Functions.TryGetValue(fileName); if (expectedStr == null) { throw new AssertFailedException($"The function baseline file for namespace '{@namespace.Name}' does not exist."); } var expected = JToken.Parse(expectedStr); var expectedPath = Path.Combine("src", "Bicep.Core.Samples", "Files", DataSet.TestFunctionsDirectory, fileName); actual.Should().EqualWithJsonDiffOutput(TestContext, expected, expectedPath, actualLocation); }
protected override void CacheMetadata(CodeActivityMetadata metadata) { Collection <RuntimeArgument> arguments = new Collection <RuntimeArgument>(); Type targetObjectType = TypeHelper.ObjectType; if (this.TargetObject != null) { targetObjectType = this.TargetObject.ArgumentType; } RuntimeArgument targetObjectArgument = new RuntimeArgument("TargetObject", targetObjectType, ArgumentDirection.In); metadata.Bind(this.TargetObject, targetObjectArgument); arguments.Add(targetObjectArgument); _resultArgument = new RuntimeArgument("Result", typeof(TResult), ArgumentDirection.Out); metadata.Bind(this.Result, _resultArgument); arguments.Add(_resultArgument); // Parameters are named according to MethodInfo name if DetermineMethodInfo // succeeds, otherwise arbitrary names are used. _methodResolver = CreateMethodResolver(); _methodResolver.DetermineMethodInfo(metadata, s_funcCache, s_locker, ref _methodExecutor); _methodResolver.RegisterParameters(arguments); metadata.SetArgumentsCollection(arguments); _methodResolver.Trace(); if (_methodExecutor != null) { _methodExecutor.Trace(this); } }
protected CandidateMethod ResolveExtension(IEnumerable <MethodInfo> candidates) { var resolver = new MethodResolver(GetExtensionArgumentTypes()); return(resolver.ResolveMethod(candidates)); }
protected Type[] GetExtensionArgumentTypes() { return(MethodResolver.GetArgumentTypes(GetExtensionArgs())); }
protected Type[] GetArgumentTypes() { return(MethodResolver.GetArgumentTypes(_arguments)); }
public EventPropertyWriter GetWriter(string propertyName) { if (_writeablePropertyDescriptors == null) { InitializeWriters(); } Pair<EventPropertyDescriptor, BeanEventPropertyWriter> pair = _writerMap.Get(propertyName); if (pair != null) { return pair.Second; } Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyName); if (property is MappedProperty) { var mapProp = (MappedProperty) property; var methodName = PropertyHelper.GetSetterMethodName(mapProp.PropertyNameAtomic); MethodInfo setterMethod; try { setterMethod = MethodResolver.ResolveMethod( _clazz, methodName, new Type[] { typeof (string), typeof (object) }, true, new bool[2], new bool[2]); } catch (EngineNoSuchMethodException e) { Log.Info( "Failed to find mapped property setter method '" + methodName + "' for writing to property '" + propertyName + "' taking {string, Object} as parameters"); return null; } if (setterMethod == null) { return null; } FastMethod fastMethod = _fastClass.GetMethod(setterMethod); return new BeanEventPropertyWriterMapProp(_clazz, fastMethod, mapProp.Key); } if (property is IndexedProperty) { var indexedProp = (IndexedProperty) property; var methodName = PropertyHelper.GetSetterMethodName(indexedProp.PropertyNameAtomic); MethodInfo setterMethod; try { // setterMethod = UnderlyingType.GetMethod( // methodName, BindingFlags.Public | BindingFlags.Instance, null, // new Type[] { typeof(int), typeof(object) }, null); setterMethod = MethodResolver.ResolveMethod( _clazz, methodName, new Type[] { typeof (int), typeof (object) }, true, new bool[2], new bool[2]); } catch (EngineNoSuchMethodException) { Log.Info( "Failed to find indexed property setter method '" + methodName + "' for writing to property '" + propertyName + "' taking {int, Object} as parameters"); return null; } if (setterMethod == null) { return null; } FastMethod fastMethod = _fastClass.GetMethod(setterMethod); return new BeanEventPropertyWriterIndexedProp(_clazz, fastMethod, indexedProp.Index); } return null; }