public void Process(IClassBuilder builder, Type typeToParse) { //This is so inefficient. We do this so often, thankfully it's technically cached. //Anyway, we need the member types again. IEnumerable<MemberInfo> parsedInfos = typeParser.Parse(System.Reflection.MemberTypes.Property | System.Reflection.MemberTypes.Field, typeToParse); //Should now be a collection of only Action fields IEnumerable<MemberInfo> actionInfoTypes = parsedInfos.Where(x => actionMapper.isActionType(x.Type())); foreach(MemberInfo mi in actionInfoTypes) { //this class can't handle generic events if (actionMapper.isGenericActionType(mi.Type())) { //get a new class name that is shared across all events of the same sig string newClassName = actionMapper.GetSharedGenericEventTypeName(mi.Type().GetGenericArguments()); eventTracker.Register(newClassName, mi.Type().GetGenericArguments()); //register info about the generic event to be tracked //we can add the field to the class now builder.AddClassField(new UnitySerializedFieldImplementationProvider(mi.Name, newClassName, new Common.Unity3D.WiredToAttribute(mi.MemberType, mi.Name, mi.Type()))); } else //action mapper can resolve Action/TestityEvent types //Non-generic events require no messing with builder.AddClassField(new UnitySerializedFieldImplementationProvider(mi.Name, actionMapper.ResolveMappedType(mi.Type()), new Common.Unity3D.WiredToAttribute(mi.MemberType, mi.Name, mi.Type()))); } }
public void Process(IClassBuilder builder, Type typeToParse) { IEnumerable<MemberInfo> serializedMemberInfos = typeParser.Parse(MemberTypes.Field | MemberTypes.Property, typeToParse); List<IInitializationExpression> initExpressions = new List<IInitializationExpression>(serializedMemberInfos.Count()); foreach (MemberInfo mi in serializedMemberInfos) { //find a an experssion builder for the source -> dest type IInitializationExpressionBuilder expressionBuilder = initExpressionBuildProvider.FromReflectionData(typeResolver.ResolveMappedType(mi.Type()), mi.Type()); if (expressionBuilder == null) continue; //this is for testing. Don't do this in the future. else { IInitializationExpression expression = expressionBuilder.Build(new InitializationExpressionData(mi.Name, mi.MemberType, mi.Name), typeof(TestityBehaviour<>).MembersWith<ImplementationField>(MemberTypes.Field, Flags.InstanceAnyVisibility).First().Name); //get the testity field we need to assign this too if (expression == null) throw new InvalidOperationException("Unable to build expression for init for Member: " + mi.Name + " in Type: " + mi.Type().ToString()); initExpressions.Add(expression); } } //Give the block provider the expressions we want and find the name of the field in the MonoBehaviour that must be set. UnityInitializationMethodImplementationProvider blockProvider = new UnityInitializationMethodImplementationProvider(initExpressions); //Using the default member provider and the block provider we quite complexly just built above we can add the initialization method. builder.AddMemberMethod(new DefaultMemberImplementationProvider(typeof(void), MemberImplementationModifier.Override | MemberImplementationModifier.Protected, "InitializeScriptComponentMemberValues"), blockProvider); }
public void Process(IClassBuilder builder, Type typeToParse) { if (builder == null) throw new ArgumentNullException(nameof(builder), "Class builder cannot be null."); if (typeToParse == null) throw new ArgumentNullException(nameof(typeToParse), "Type for the generic arg cannot be null."); #if DEBUG || DEBUGBUILD if (!typeof(EngineScriptComponent).IsAssignableFrom(typeToParse)) throw new InvalidOperationException("Cannot parse Type: " + typeToParse + " for a " + typeof(TestityBehaviour<>) + " because it doesn't inherit from " + typeof(EngineScriptComponent)); #endif builder.AddBaseClass(new DefaultTypeSyntaxBuilder(), typeof(TestityBehaviour<>).MakeGenericType(typeToParse)); }
public void Process(IClassBuilder builder, Type typeToParse) { //This can be done in a way that preserves order but that is not important in the first Testity build. //We can improve on that later //handle serialized fields and properties foreach (MemberInfo mi in typeParser.Parse(MemberTypes.Field | MemberTypes.Property, typeToParse)) { //Some types are no serialized or are serialized in later steps if (typesNotToSerialize.isExcluded(mi.Type())) continue; builder.AddClassField(new UnitySerializedFieldImplementationProvider(mi.Name, typeResolver.ResolveMappedType(mi.Type()), new Common.Unity3D.WiredToAttribute(mi.MemberType, mi.Name, mi.Type()))); } }
public ClassContentFactory(IClassBuilder classBuilder) { _classBuilder = classBuilder; }
protected abstract bool ImplementProperty(IClassBuilder impl, PropertyInfo propertyInfo, INamedReference serviceLocatorField);
/// <summary> /// /// </summary> /// <typeparam name="TComponent"></typeparam> /// <param name="builder"></param> /// <param name="value"></param> /// <returns></returns> public static IClassBuilder <TComponent> Modifier <TComponent>(this IClassBuilder <TComponent> builder, string value, Predicate <TComponent> condition) where TComponent : BootstrapComponentBase { return(builder.Modifier(_ => value, condition)); }
protected virtual void ImplementCall( Type controllerType, MethodInfo method, INamedReference contextParameter, INamedReference resultVar, Func <Type, INamedReference> privateObjectsFactory, IClassBuilder proxyBuilder, INamedReference interceptorField, ICodeBlockBuilder block) { var argumentsArray = block.Var(ini => ini.Write($"new System.Object[{method.GetParameters().Length}]")); block.Write("try {\r\n"); var methodInfoField = proxyBuilder.HasField(typeof(MethodInfo)) .WithModifier("static") .WithModifier("private") .WithModifier("readonly") .WithAssignment( asg => asg.Write(typeof(ReflectonWrapper)) .Write(".") .Write(nameof(ReflectonWrapper.GetMethodInfo)) .Write("(") .Typeof(controllerType) .Write(",") .String(method.Name) .Write(")")); var paramVars = new List <INamedReference>(method.GetParameters().Length); var parameterIndex = 0; foreach (var param in method.GetParameters()) { var paramInfoField = proxyBuilder.HasField(typeof(ParameterInfo)) .WithModifier("static") .WithModifier("private") .WithModifier("readonly") .WithAssignment( asg => asg.Write(typeof(ReflectonWrapper)) .Write(".") .Write(nameof(ReflectonWrapper.GetParameterInfo)) .Write("(") .Typeof(controllerType) .Write(",") .String(method.Name) .Write(",") .String(param.Name) .Write(")")); var paramReaderType = GetParameterReaderType(param); var readerField = privateObjectsFactory(paramReaderType); var paramVar = block.Var(asg => ComposeParameterRead(asg, readerField, param, methodInfoField, paramInfoField, contextParameter, interceptorField)); paramVars.Add(paramVar); block.Write(argumentsArray).Write($"[{parameterIndex}] = ").Write(paramVar).EndStatement(); parameterIndex++; } var isVoid = method.ReturnType == typeof(void); var resultWriterField = privateObjectsFactory(GetResultWriterType(method)); block.Invoke( interceptorField, nameof(IControllerInterceptor.Call), args => args.WithParam("this") .WithParam(methodInfoField) .WithParam(contextParameter) .WithParam(argumentsArray) .WithParam(isVoid ? "true" : "false") .WithParam( call => { call.Write("() => {"); if (!isVoid) { call.Write("return "); } call.Invoke( method.Name, argu => { foreach (var argument in paramVars) { argu.WithParam(argument); } }).EndStatement(); if (isVoid) { call.Write("return null").EndStatement(); } call.Write(" }"); }).WithParam( result => { result.Write("__r => ") .Invoke( resultWriterField, nameof(IResultWriter.WriteResult), rinvo => rinvo.WithParam(methodInfoField) .WithParam(contextParameter) .WithParam("__r") .WithParam(isVoid ? "true" : "false")); })).EndStatement(); block.Write("} catch(System.Exception callException) {\r\n"); block.Invoke( interceptorField, nameof(IControllerInterceptor.OnException), arguments => arguments.WithParam("this") .WithParam(methodInfoField) .WithParam(contextParameter) .WithParam(argumentsArray) .WithParam("callException")).EndStatement(); block.Write("}\r\n"); block.Write("return").EndStatement(); }
/// <summary> /// /// </summary> /// <typeparam name="TComponent"></typeparam> /// <param name="func"></param> /// <param name="condition"></param> /// <returns></returns> public static IClassBuilder <TComponent> Modifier <TComponent>(this IClassBuilder <TComponent> builder, Func <TComponent, string> func) where TComponent : BootstrapComponentBase { return(builder.Modifier(func, _ => true)); }
/// <summary> /// /// </summary> /// <typeparam name="TComponent"></typeparam> /// <param name="builder"></param> /// <param name="value"></param> /// <returns></returns> public static IClassBuilder <TComponent> Modifier <TComponent>(this IClassBuilder <TComponent> builder, string value) where TComponent : BootstrapComponentBase { return(builder.Modifier(_ => value, _ => true)); }
/// <summary> /// /// </summary> /// <typeparam name="TComponent"></typeparam> /// <param name="builder"></param> /// <param name="value"></param> /// <returns></returns> public static IClassBuilder <TComponent> Name <TComponent>(this IClassBuilder <TComponent> builder, string value) where TComponent : BootstrapComponentBase { return(builder.Name(_ => value)); }
public void Process(IClassBuilder builder, Type typeToParse) { throw new NotImplementedException(); }
public ModelGenerator(IClassBuilder builder, IPropertyGenerator propertyGenerator, IAddinContainer container, string namespaceName, string parentElementName) : base(builder, propertyGenerator, container, namespaceName) { _parentFieldName = parentElementName; }
public ComparablePropertiesInClassContextBuilder(IClassBuilder <T> classBuilder, Expression <Func <T, IComparable> > propertyExpression) { this.classBuilder = classBuilder; this.propertyExpression = propertyExpression; }
public PropertiesInClassContextBuilder(IClassBuilder <T> classBuilder, Expression <Func <T, object> > propertyExpression) { this.classBuilder = classBuilder; this.propertyExpression = propertyExpression; }