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