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