public void Route(IStateMember stateMember, Type runtimeMemberType, object owner, bool skipSpecialMethod = true)
{
VisitMember((IReflectionStateMember)stateMember,
owner,
runtimeMemberType,
skipSpecialMethod, true);
}
public BinaryStateMember(IStateMember stateMember,
bool knownType,
bool headerHandled = false)
{
_stateMember = stateMember;
_knownType = knownType;
_headerHandled = headerHandled;
}
public Func <object, T> GetGetter <T>(IStateMember member)
{
ParameterExpression instance = Expression.Parameter(typeof(object));
Expression <Func <object, T> > lambda =
Expression.Lambda <Func <object, T> >
(GetGetterExpression <T>(member, instance),
"Getter_" + member.Name,
new[] { instance });
return(_compiler.Compile(lambda));
}
public void ProcessEnumForReadOnly <[IsEnum] TEnum, TUnderlying>
(IReadOnlyEnumExactValueDescriptor <TEnum, TUnderlying> descriptor)
where TUnderlying : IConvertible
where TEnum : IConvertible
{
WriteAssemblyQualifiedNameIfNeeded((BinaryStateMember)descriptor.StateMember, typeof(TEnum));
IStateMember underlying = descriptor.UnderlyingValueStateMember;
descriptor.Route(new BinaryStateMember(underlying, true, true),
descriptor.Owner,
true);
}
public Action <object, T> GetSetter <T>(IStateMember member)
{
ParameterExpression instance = Expression.Parameter(typeof(object));
ParameterExpression value = Expression.Parameter(typeof(T));
Expression <Action <object, T> > lambda =
Expression.Lambda <Action <object, T> >
(member.GetSetExpression(instance, value),
"Setter_" + member.Name,
new[] { instance, value });
return(_compiler.Compile(lambda));
}
public MemberLocal(IClimbStore climbStore,
IStateMember member)
{
_member = member;
_getter =
new Lazy <Func <object, TField> >(() => climbStore.GetGetter <TField>(member));
_setter =
new Lazy <Action <object, TField> >(() => climbStore.GetSetter <TField>(member));
_climb =
new Lazy <ClimbDelegate <TRuntime> >
(() => climbStore.GetClimb <TRuntime>(typeof(TRuntime)));
_structClimb =
new Lazy <ClimbDelegate <object> >
(() => climbStore.GetClimb <object>(typeof(TRuntime)));
}
public void ProcessEnumForWriteOnly <[IsEnum] TEnum, TUnderlying>
(IEnumReadWriteExactValueDescriptor <TEnum, TUnderlying> descriptor)
where TUnderlying : IConvertible
where TEnum : IConvertible
{
IStateMember underlying = descriptor.UnderlyingValueStateMember;
bool handled = false;
var olderStateMember = descriptor.StateMember as BinaryStateMember;
if (olderStateMember != null && olderStateMember.HeaderHandled)
{
handled = true;
}
descriptor.Route(new BinaryStateMember(underlying, true, handled),
descriptor.Owner,
true);
}
public static Type GetDescriptorType(IStateMember member, Type runtimeType)
{
if (member.CanRead && member.CanWrite)
{
if (runtimeType.IsEnum)
{
return(typeof(EnumReadWriteDescriptor <, ,>)
.MakeGenericType(member.MemberType, runtimeType, runtimeType.GetEnumUnderlyingType()));
}
// Assume field type == runtime type
return(typeof(ReadWriteDescriptor <,>).
MakeGenericType(member.MemberType, runtimeType));
}
if (member.CanRead)
{
if (runtimeType.IsEnum)
{
return(typeof(EnumReadOnlyDescriptor <, ,>)
.MakeGenericType(member.MemberType, runtimeType, runtimeType.GetEnumUnderlyingType()));
}
return(typeof(ReadOnlyDescriptor <,>)
.MakeGenericType(member.MemberType, runtimeType));
}
if (member.CanWrite)
{
if (runtimeType.IsEnum)
{
return(typeof(EnumWriteOnlyDescriptor <,>)
.MakeGenericType(runtimeType, runtimeType.GetEnumUnderlyingType()));
}
return(typeof(WriteOnlyDescriptor <>)
.MakeGenericType(runtimeType));
}
throw new Exception("Are you kidding me?!");
}
public MethodInfo GetMethod(Type processorType, IStateMember member, Type runtimeType, bool routed)
{
Type descriptorType = DescriptorExtensions.GetDescriptorType(member, runtimeType);
// TODO: First implementation: reimplement this.
GenericArgumentBinder binder =
new GenericArgumentBinder
(new FallbackToFirstCandidateMethodSelector
(new BinderMethodSelector(Type.DefaultBinder)));
// TODO: Return this after processors are fixed.
// IEnumerable<Type> typesToSearch = processorType.WithInterfaces();
IEnumerable <Type> typesToSearch = processorType.AsEnumerable();
IEnumerable <MethodInfo> methods =
typesToSearch.SelectMany(x => x.GetMethods())
.Where(x => x.IsDefined(typeof(ProcessorMethodAttribute)))
.Where(x => !x.GetCustomAttribute <ProcessorMethodAttribute>().OnlyOnRoute ||
routed);
IEnumerable <IGrouping <int, MethodInfo> > candidates =
methods.Select(method => Bind(binder, method, descriptorType))
.Where(x => x != null)
.GroupBy(x => x.GetCustomAttribute <ProcessorMethodAttribute>().Precedence)
.OrderBy(x => x.Key);
IGrouping <int, MethodInfo> maximum = candidates.FirstOrDefault();
if (maximum.Skip(1).Any())
{
throw new Exception("Too many candidates for the processor thingy. Use precedence.");
}
else
{
MethodInfo method = maximum.FirstOrDefault();
return(method);
}
}
public RouteDelegate GetRouteDelegate(IStateMember member, Type runtimeMemberType)
{
ParameterExpression processor = Expression.Parameter(typeof(object), "processor");
ParameterExpression owner = Expression.Parameter(typeof(object), "owner");
ParameterExpression skipSpecialMethods = Expression.Parameter(typeof(bool), "skipSpecialMethods");
var castedProcessor =
processor.Convert(_processorType);
DescriptorWriter descriptorWriter = new DescriptorWriter(_climbStore);
DescriptorVariable descriptor =
descriptorWriter.GetDescriptor(processor, owner, member, runtimeMemberType);
MethodInfo methodToCall =
_methodMapper.GetMethod(_processorType, member, runtimeMemberType, true);
MethodCallExpression callProcess =
Expression.Call(castedProcessor, methodToCall, descriptor.Reference);
Expression callProcessWithSpecialMethods =
_specialMutator.Mutate(callProcess, castedProcessor, owner, member, descriptor.Reference);
BlockExpression body =
Expression.Block(new[] { descriptor.Reference },
descriptor.Declaration,
Expression.Condition(skipSpecialMethods,
callProcess,
callProcessWithSpecialMethods));
Expression <RouteDelegate> lambda =
Expression.Lambda <RouteDelegate>(body,
"Route_" + runtimeMemberType.Name,
new[] { processor, owner, skipSpecialMethods });
return(_compiler.Compile(lambda));
}
public void Route(IStateMember stateMember, object owner, bool skipSpecialMethod)
{
Route(stateMember, stateMember.MemberType, owner, skipSpecialMethod);
}
public void Route(IStateMember stateMember, Type runtimeMemberType, object owner, bool skipSpecialMethod)
{
RouteDelegate route = _climbStore.GetRoute(stateMember, runtimeMemberType);
route(_processor, owner, skipSpecialMethod);
}
public Expression Mutate(Expression oldExpression, Expression processor, Expression owner, IStateMember member, Expression descriptor)
{
if (!member.CanRead)
{
return(oldExpression);
}
Type memberType = member.MemberType;
if (memberType.IsValueType || memberType.IsSealed)
{
return(oldExpression);
}
ParameterExpression runtimeType = Expression.Variable(typeof(Type), member.Name.FirstLowerCase() + "RuntimeType");
var memberTypeConstant = memberType.Constant();
var value = member.GetGetExpression(owner);
var runtimeTypeAssign =
Expression.Condition(Expression.Equal(value, ExpressionExtensions.Null),
Expression.Assign(runtimeType, memberTypeConstant),
Expression.Assign(runtimeType, Expression.Call(value, _getTypeMethod)));
var routeCall =
Expression.Call(descriptor,
_routeMethod,
Expression.Constant(member),
runtimeType,
owner.Convert <object>(),
Expression.Constant(true));
if (memberType.IsAbstract || memberType.IsInterface)
{
// Replace the call with a route in this case.
BlockExpression block =
Expression.Block(new[] { runtimeType },
runtimeTypeAssign,
routeCall);
return(block);
}
else
{
// The code that should be generated is this :
// Type runtimeType;
// if (value != null)
// {
// runtimeType = value.GetType();
// }
// else
// {
// runtimeType = memberType;
// }
//
// if (runtimeType == memberType)
// {
// oldExpression();
// }
// else
// {
// descriptor.Route(member, runtimeType, owner, true);
// }
//
Expression result =
Expression.Block(new[] { runtimeType },
runtimeTypeAssign,
Expression.Condition
(Expression.Equal(runtimeType, member.MemberType.Constant()),
oldExpression,
routeCall));
return(result);
}
}
public void Route(IStateMember stateMember, object current, TProcessor processor, bool skipSpecialMethod)
{
throw new NotImplementedException();
}
public MemberTypeStateMember(IStateMember underlying, Type memberType)
{
_underlying = underlying;
_memberType = memberType;
}
public Action <object, T> GetSetter <T>(IStateMember member)
{
return(_setters.GetOrAdd
(member,
key => _accessorFactory.GetSetter <T>(key)));
}
public Func <object, T> GetGetter <T>(IStateMember member)
{
return(_getters.GetOrAdd
(member,
key => _accessorFactory.GetGetter <T>(key)));
}
private void WritePropertyName(IValueDescriptor descriptor)
{
IStateMember stateMember = descriptor.StateMember;
_writer.WriteStartElement(stateMember.Name);
}
public DescriptorVariable GetDescriptor(Expression processor, Expression owner, IStateMember member, Type runtimeType)
{
return(new DescriptorVariable(_store, processor, owner, member, runtimeType));
}
public Expression GetExpression
(Expression processor, Expression owner, IStateMember member, Expression descriptor)
{
return(_mutator.Mutate(Expression.Empty(), processor, owner, member, descriptor));
}
public NamedStateMember(IStateMember underlying, string name)
{
_underlying = underlying;
_name = name;
}
public static IStateMember WithMemberType(this IStateMember stateMember, Type memberType)
{
return(new MemberTypeStateMember(stateMember, memberType));
}
public static IStateMember WithName(this IStateMember stateMember, string name)
{
return(new NamedStateMember(stateMember, name));
}
public DescriptorVariable(IClimbStore store, Expression processor, Expression owner, IStateMember member, Type runtimeType)
{
Type descriptorType =
DescriptorExtensions.GetDescriptorType(member, runtimeType);
Type memberLocalType =
typeof(MemberLocal <,>).MakeGenericType(member.MemberType, runtimeType);
_reference = Expression.Variable(descriptorType, member.Name.FirstLowerCase() + "Descriptor");
object memberLocal = Activator.CreateInstance(memberLocalType, store, member);
ConstructorInfo constructor = descriptorType.GetConstructors().FirstOrDefault();
ParameterInfo ownerParameter = constructor.GetParameters()[1];
Type ownerParameterType = ownerParameter.ParameterType;
NewExpression creation =
Expression.New(constructor,
processor,
owner.Convert(ownerParameterType),
memberLocal.Constant(),
store.Constant());
BinaryExpression assign = Expression.Assign(_reference, creation);
_descriptorDeclaration = assign;
}
public void Route(IStateMember stateMember, object current, TProcessor processor, bool skipSpecialMethod)
{
_climbStore.GetRoute(stateMember, current.GetType())(processor, current, skipSpecialMethod);
}
private static Expression GetGetterExpression <T>(IStateMember member, Expression instance)
{
// We need to convert to the type, since sometimes we fake the member type.
return(member.GetGetExpression(instance).Convert(typeof(T)));
}
public Expression Mutate(Expression oldExpression, Expression processor, Expression owner, IStateMember member, Expression descriptor)
{
MethodInfo methodToCall =
_methodMapper.GetMethod(_processorType, member, member.MemberType, _routed);
MethodCallExpression callProcessor =
Expression.Call(processor, methodToCall, descriptor);
Expression result = callProcessor;
return(result);
}
public RouteDelegate GetRoute(IStateMember member, Type runtimeMemberType)
{
return(_routes.GetOrAdd(member, runtimeMemberType,
(memberKey, runtimeTypeKey) =>
_routeFactory.GetRouteDelegate(memberKey, runtimeTypeKey)));
}
public ReflectionEnumValueDescriptor(object processor, IStateMemberProvider stateMemberProvider, IReflectionStateMember stateMember, object owner) :
base(processor, stateMemberProvider, stateMember, owner)
{
_underlyingValueStateMember = new EnumUnderlyingValueStateMember(stateMember);
}
public Expression Mutate(Expression oldExpression, Expression processor, Expression owner, IStateMember member, Expression descriptor)
{
return(_mutator.Mutate(oldExpression, processor, owner, member, descriptor));
}
