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