/// <summary>
/// Intercepts the specified invocation.
/// </summary>
/// <param name="invocation">The invocation.</param>
public void Intercept(IInvocation invocation)
{
Contract.Assume(this.interfaceMap.Subject != null);
Contract.Assume(invocation != null);
Contract.Assume(invocation.Arguments != null);
Contract.Assume(invocation.Method != null);
Type[] lArgumentTypes = Type.GetTypeArray(invocation.Arguments);
string lMethodName = invocation.Method.Name;
Contract.Assume(!string.IsNullOrEmpty(lMethodName));
MappedMethod mapping = this.interfaceMap.GetMappedMethod(
this.interfaceMap.Subject.GetType(),
lMethodName,
lArgumentTypes,
invocation.GenericArguments);
Contract.Assume(mapping != null);
invocation.ReturnValue = mapping(invocation.Arguments);
if (invocation.InvocationTarget != null)
{
invocation.Proceed();
}
}
/// <summary>
/// Gets the mapped method.
/// </summary>
/// <param name="typeOfTheSubject">The type of the subject.</typeparam>
/// <param name="name">The method name.</param>
/// <param name="argTypes">The arguments passed in to the method.</param>
/// <param name="genericArgs">The generic argument types.</param>
/// <returns>
/// The mapped method
/// </returns>
public MappedMethod GetMappedMethod(Type typeOfTheSubject, string name, Type[] argTypes, params Type[] genericArgs)
{
argTypes = argTypes ?? Type.EmptyTypes;
genericArgs = genericArgs ?? Type.EmptyTypes;
Contract.Assume(!string.IsNullOrEmpty(name));
IMethodMapping mapping = this.Lookup(name, argTypes, genericArgs);
if (mapping == default(IMethodMapping))
{
Fasterflect.MethodInvoker invoker = typeOfTheSubject.GetMethod(name, argTypes, genericArgs);
// TODO: Abstract IMethodMapping creation?
mapping = new MethodMapping()
{
Name = name,
ArgumentTypes = argTypes,
GenericArgumentTypes = genericArgs ?? Type.EmptyTypes,
Subject = (subject, args) => invoker(subject, args)
};
this.Add(mapping);
}
MappedMethod method = (args) =>
{
return(mapping.Subject(this.Subject, args));
};
return(method);
}
public void Compile(Mappings result, ModuleDefinition module)
{
foreach (var typeDefinition in module.GetAllTypes())
{
var type = new MappedType(typeDefinition.FullName, GetOrDefault(typeDefinition.Name));
foreach (var methodDefinition in typeDefinition.Methods)
{
if (methodDefinition.Name.IsObfuscated() && !Names.ContainsKey(methodDefinition.Name))
{
continue; // dead method
}
var method = new MappedMethod(methodDefinition, GetOrDefault(methodDefinition.Name));
foreach (var parameterDefinition in methodDefinition.Parameters)
{
method.Parameters.Add(GetOrDefault(parameterDefinition.Name) ?? parameterDefinition.Name);
}
if (!methodDefinition.Name.IsObfuscated() && !method.Parameters.Any())
{
continue;
}
type.Methods.Add(method);
}
foreach (var fieldDefinition in typeDefinition.Fields)
{
var field = new MappedMember(fieldDefinition.Name, GetOrDefault(fieldDefinition.Name) ?? fieldDefinition.Name.Clean());
if (!fieldDefinition.Name.IsObfuscated() && fieldDefinition.Name == field.Mapped)
{
continue;
}
type.Fields.Add(field);
}
foreach (var propertyDefinition in typeDefinition.Properties)
{
var field = new MappedMember(propertyDefinition.Name, GetOrDefault(propertyDefinition.Name));
if (!propertyDefinition.Name.IsObfuscated())
{
continue;
}
type.Properties.Add(field);
}
if (!typeDefinition.Name.IsObfuscated() && !type.Fields.Any() && !type.Methods.Any() && !type.Properties.Any() && !type.Nested.Any())
{
continue;
}
result.Types.Add(type);
}
}
/// <summary>
/// Processes the method invokation.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <typeparam name="TSubject">The type of the subject.</typeparam>
/// <param name="name">The method name.</param>
/// <param name="argTypes">The arg types.</param>
/// <param name="genericArgs">The generic type arguments</param>
/// <returns>
/// The result of the call (null if the method is declared as void)
/// </returns>
public MappedMethod <TResult> GetMappedMethod <TResult, TSubject>(string name, Type[] argTypes, params Type[] genericArgs)
{
argTypes = argTypes ?? Type.EmptyTypes;
MappedMethod mapping = this.GetMappedMethod <TSubject>(name, argTypes, genericArgs);
return((args) => (TResult)mapping(args));
}
/// <summary>
/// Maps a member from the type's definition to its constructed version.
/// </summary>
public IEntity MapMember(IEntity source)
{
if (source == null)
{
return(null);
}
if (_mappedMembers.ContainsKey(source))
{
return(_mappedMembers[source]);
}
IEntity mapped = null;
switch (source.EntityType)
{
case EntityType.Method:
mapped = new MappedMethod(_typeSystemServices, ((ExternalMethod)source).MethodInfo, this);
break;
case EntityType.Constructor:
mapped = new MappedConstructor(_typeSystemServices, ((ExternalConstructor)source).ConstructorInfo, this);
break;
case EntityType.Field:
mapped = new MappedField(_typeSystemServices, ((ExternalField)source).FieldInfo, this);
break;
case EntityType.Property:
mapped = new MappedProperty(_typeSystemServices, ((ExternalProperty)source).PropertyInfo, this);
break;
case EntityType.Type:
mapped = MapType((IType)source);
break;
case EntityType.Event:
mapped = new MappedEvent(_typeSystemServices, ((ExternalEvent)source).EventInfo, this);
break;
default:
throw new ArgumentException(
string.Format("Invalid entity type for mapping: {0}.", source.EntityType));
}
_mappedMembers[source] = mapped;
return(mapped);
}
/// <summary>
/// Creates functionmetadata object with the supplied inputs.
/// </summary>
/// <param name="memberType">What type of member e.g. property,function.</param>
/// <param name="name">The name of the function</param>
/// <param name="implementationMethod">The method that implements the funcion in this host language.</param>
/// <param name="returnType">The return values type</param>
/// <param name="description">Description of the function.</param>
/// <returns></returns>
private FunctionMetaData AddMethodInfo(MemberTypes memberType, string name, string implementationMethod, Type returnType, string description)
{
var funcdef = new FunctionMetaData(name, null);
funcdef.Doc = new Docs.DocTags();
// Todo:
funcdef.ReturnType = LangTypeHelper.ConvertToLangType(returnType);
funcdef.Doc.Summary = description;
var mappedMethod = new MappedMethod();
mappedMethod.DataTypeMethod = name;
mappedMethod.HostLanguageMethod = implementationMethod;
mappedMethod.FuncDef = funcdef;
_methodMap[name] = mappedMethod;
_allMembersMap[name] = memberType;
return(funcdef);
}
/// <summary>
/// Creates functionmetadata object with the supplied inputs.
/// </summary>
/// <param name="memberType">What type of member e.g. property,function.</param>
/// <param name="name">The name of the function</param>
/// <param name="implementationMethod">The method that implements the funcion in this host language.</param>
/// <param name="returnType">The return values type</param>
/// <param name="description">Description of the function.</param>
/// <returns></returns>
private FunctionMetaData AddMethodInfo(MemberTypes memberType, string name, string implementationMethod, Type returnType, string description, bool convertParams)
{
var funcdef = new FunctionMetaData(name, null);
funcdef.Doc = new DocTags();
// Todo:
funcdef.ReturnType = LangTypeHelper.ConvertToLangType(returnType);
funcdef.Doc.Summary = description;
var mappedMethod = new MappedMethod();
mappedMethod.DataTypeMethod = name;
mappedMethod.HostLanguageMethod = implementationMethod;
mappedMethod.FuncDef = funcdef;
mappedMethod.ConvertParameters = convertParams;
_methodMap[name] = mappedMethod;
_allMembersMap[name] = memberType;
return funcdef;
}
protected void MapMethods(string pattern, string method, RequestDelegate requestDelegate)
{
var methodItem = new MappedMethod(pattern, method, requestDelegate);
_methods.Add(methodItem);
}
