public ICodeBlockBuilder InvokeGenericMethod(
INamedReference targetObject,
string methodName,
Type[] genericArguments,
Action <IInvocationBuilder> invocation)
{
Write(targetObject).Write(".").Write(methodName);
if ((genericArguments != null) && (genericArguments.Length > 0))
{
Write("<");
for (var i = 0; i < genericArguments.Length; i++)
{
if (i > 0)
{
Write(", ");
}
Write(genericArguments[i]);
}
Write(">");
}
Write("(");
var ib = new InvocationBuilder(this);
invocation(ib);
return(Write(")"));
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
var implementingType = setup.ImplementingType ?? setup.InterfaceType;
var methodName = $"Factory{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_{Guid.NewGuid():N}";
var method = locatorBuilder.HasMethod(methodName).WithModifier("private").Returns(setup.InterfaceType);
method.Body.Write("return ").InvokeConstructor(implementingType,
invocation =>
{
foreach (var constructorParameter in setup.PreferredConstructor.GetParameters())
{
INamedReference factoryField;
if (ctorParamValueFactoryFields.TryGetValue(constructorParameter.Name, out factoryField))
{
invocation.WithParam(b => b.Write("(").Write(constructorParameter.ParameterType).Write(")").Write(factoryField).Write("(this)"));
}
else
{
invocation.WithParam(b => b.Write("(").Write(constructorParameter.ParameterType).Write(")").Write("Get(typeof(").Write(constructorParameter.ParameterType).Write("))"));
}
}
}).EndStatement();
return(method);
}
public ClassBuilder(string name, int indent)
: base(name)
{
m_baseClass = GetTypeReference(typeof(object));
m_indent = indent;
m_constructor = new ConstructorBuilder(name, indent + 1);
}
public INamedReference WithParam(string name, INamedReference typeReference)
{
if (!m_parameters.Any(p => p.Key == name))
{
m_parameters.Add(new KeyValuePair <string, INamedReference>(name, typeReference));
}
return(new NamedReference(name));
}
public ICodeBlockBuilder Compare(INamedReference a, Action <ICodeBlockBuilder> b)
{
Write(a);
Write(" == ");
b(this);
return(this);
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
if (!IsApplicable(setup))
{
return(previousPluginMethod);
}
var behavior = setup.Behaviors.OfType <EntityBehavior>().Last();
var entityClass =
locatorBuilder.HasNestedClass($"{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_Impl_{Guid.NewGuid():N}")
.WithModifier("private")
.WithModifier("sealed")
.Implements <IEntity>()
.Implements(setup.InterfaceType);
var locatorField = entityClass.HasField <IServiceLocator>();
var ctor = entityClass.WithConstructor().WithModifier("public");
var locatorParam = ctor.WithParam <IServiceLocator>("locator");
ctor.Body.Assign(locatorField, a => a.Write(locatorParam)).EndStatement();
ctor.Body.Write("IsDirty = true").EndStatement();
var entityProperties = ImplementProperties(entityClass, setup.InterfaceType, behavior).ToList();
ImplementIsDirtyProperty(entityClass);
var pkProperty = ImplementReadPrimaryKeyAndGetPkProperty(entityClass, behavior, setup.InterfaceType);
ImplementGetSaveMethodTypeMethod(entityClass, pkProperty);
ImplementGetValuesMethod(entityClass, entityProperties, pkProperty);
ImplementReadSelfMethod(entityClass, locatorField, entityProperties);
ImplementReferenceEntityProperties(entityClass, setup.InterfaceType, m_setup.EntityNamingConvention);
ImplementDbEntityNameProperty(entityClass, setup.InterfaceType);
ImplementPkTypeProperty(entityClass, pkProperty);
ImplementIsPkAuto(entityClass, pkProperty);
var collectionMethod = locatorBuilder.HasMethod("GetEntitiesCollection").Returns(typeof(IEnumerable <Type>));
collectionMethod.Body.Write("yield return typeof(")
.Write(setup.InterfaceType)
.Write(")")
.EndStatement()
.NewLine();
var factoryMethod = locatorBuilder.HasMethod($"{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_{Guid.NewGuid():N}").Returns(setup.InterfaceType);
factoryMethod.Body.Write("return ")
.InvokeConstructor(entityClass, inv => inv.WithParam("this"))
.EndStatement();
return(factoryMethod);
}
public ICodeBlockBuilder Invoke(INamedReference targetObject, string methodName, Action <IInvocationBuilder> invocation)
{
Write(targetObject).Write(".").Write(methodName).Write("(");
var ib = new InvocationBuilder(this);
invocation(ib);
return(Write(")"));
}
public ICodeBlockBuilder InvokeConstructor(INamedReference ctorType, Action <IInvocationBuilder> invocation)
{
var ib = new InvocationBuilder(this);
Write("new ").Write(ctorType).Write("(");
invocation(ib);
return(Write(")"));
}
public ICodeBlockBuilder ForEach(INamedReference collection, Action <INamedReference, ICodeBlockBuilder> itemVariableAndInnerBlock)
{
var variableName = new NamedReference($"v{Guid.NewGuid():N}");
Write("foreach(var ").Write(variableName).Write(" in ").Write(collection).Write(")").NewLine();
InnerBlock(i => itemVariableAndInnerBlock(variableName, i));
return(NewLine());
}
public ICodeBlockBuilder Invoke(INamedReference target, Action <IInvocationBuilder> invocation)
{
var ib = new InvocationBuilder(this);
Write(target).Write("(");
invocation(ib);
return(Write(")"));
}
public bool IsSourceBranch(INamedReference sourceBranchCandidate)
{
if (Equals(sourceBranchCandidate, this.branch))
{
return(false);
}
var branchName = sourceBranchCandidate.Name.Friendly;
return(this.sourceBranchRegexes
.Any(regex => Regex.IsMatch(branchName, regex)));
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
var method = locatorBuilder.HasMethod("error");
method.Body.Write("cannot compile this");
return(method);
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
var implClass =
locatorBuilder.HasNestedClass(
$"{TypeNameHelper.GetTypeMark(this.GetType())}_implements_{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_{Guid.NewGuid():N}")
.Implements(setup.InterfaceType)
.WithModifier("private")
.WithModifier("sealed");
var locatorField = implClass.HasField <IServiceLocator>();
var locatorParam = implClass.WithConstructor().WithModifier("public").WithParam("locator", typeof(IServiceLocator));
implClass.WithConstructor().Body.Assign(locatorField, a => a.Write(locatorParam));
foreach (var property in setup.InterfaceType.GetProperties())
{
if (!ImplementProperty(implClass, property, locatorField))
{
DefaultImplementProperty(implClass, property);
}
}
foreach (var method in setup.InterfaceType.GetMethods())
{
if (method.IsSpecialName)
{
continue;
}
if (!ImplementMethod(implClass, method, locatorField))
{
DefaultImplementMethod(implClass, method);
}
}
var factoryMethod =
locatorBuilder.HasMethod($"factory_{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_{Guid.NewGuid():N}").Returns(setup.InterfaceType).WithModifier("private");
factoryMethod.Body.Write(" return ")
.InvokeConstructor(implClass, i => i.WithParam(p => p.Write("this")))
.EndStatement();
return(factoryMethod);
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
var methodName = $"Factory{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_{Guid.NewGuid():N}";
var method = locatorBuilder.HasMethod(methodName).WithModifier("private").Returns(setup.InterfaceType);
method.Body.Write("return ").Write("(").Write(setup.InterfaceType).Write(")").Write(valueFactoryField).Write("(this)").EndStatement();
return(method);
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
var collectionMethod = locatorBuilder.HasMethod("GetCollectionItems");
collectionMethod.Body.If(
condition => condition.Write("collectionType == typeof(").Write(CollectionType).Write(")"),
then => then.Write("yield return Get(typeof(").Write(setup.InterfaceType).Write("))").EndStatement()).NewLine();
return(previousPluginMethod);
}
/// <summary>
/// Gets all named references bound to formulas in the engine
/// </summary>
/// <returns>An array of named references</returns>
/// <remarks>Use this function when you need to get all the named references bound to formulas in this engine.</remarks>
public INamedReference[] GetNamedReferences()
{
IList found = new ArrayList();
foreach (DictionaryEntry de in _referenceFormulaMap)
{
if (ReferenceEquals(de.Key.GetType(), typeof(NamedReference)))
{
found.Add(de.Key);
}
}
var arr = new INamedReference[found.Count];
found.CopyTo(arr, 0);
return(arr);
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
var factory = locatorBuilder.HasMethod("GetEntityCollectorInstance").Returns(typeof(IEntityCollector));
factory.WithModifier("private");
factory.Body.Write("return new ")
.Write(typeof(EntityCollector))
.Write("(System.Linq.Enumerable.ToList(this.GetEntitiesCollection()))")
.EndStatement();
return(factory);
}
public void BuildCall(
IClassBuilder proxy,
IMethodBuilder executeMethod,
INamedReference contextParameter,
Type controllerType,
Func <Type, INamedReference> privateObjectsFactory,
INamedReference interceptorField)
{
//public void Execute(RequestContext requestContext)
var methodNameVar =
executeMethod.Body.Var(
asg =>
asg.Write(typeof(MethodNameExtractor))
.Write(".ExtractMethodName(")
.Write(contextParameter)
.Write(")"));
var resultVar = executeMethod.Body.DeclareLocal("__methodCallResult", typeof(object));
executeMethod.Body.Assign(resultVar, x => x.Write("null"));
foreach (var method in controllerType.GetMethods())
{
if ((method.DeclaringType != controllerType) && (!Attribute.IsDefined(method, typeof(CanBeInheritedAttribute))))
{
continue;
}
var methodKey = method.Name.ToLowerInvariant();
executeMethod.Body.If(
c => c.Compare(methodNameVar, b => b.String(methodKey)),
then => ImplementCall(controllerType, method, contextParameter, resultVar, privateObjectsFactory, proxy, interceptorField, then));
}
executeMethod.Body.Write("throw new ")
.Write(typeof(InvalidOperationException))
.Write("(")
.String("Unknown method: ").Write(" + ").Write(methodNameVar)
.Write(")")
.EndStatement();
}
private INamedReference CreateFactoryMethod(IClassBuilder locator, InstanceRecord record, Dictionary <string, INamedReference> allFactoryFields)
{
var ctorParamFactoryFields = new Dictionary <string, INamedReference>();
if (record.ConstructorParameters != null)
{
foreach (var ctorParam in record.ConstructorParameters)
{
if (ctorParam.ValueProvider != null)
{
ctorParamFactoryFields[ctorParam.ParameterName] = allFactoryFields[ctorParam.ValueProvider.Name];
}
}
}
INamedReference valueFactoryField = null;
if (record.Factory != null)
{
valueFactoryField = allFactoryFields[record.Factory.Name];
}
INamedReference lastFactoryMethod = null;
foreach (var plugin in record.ApplicablePlugins)
{
lastFactoryMethod = plugin.GenerateFactoryMethod(
record,
ctorParamFactoryFields,
valueFactoryField,
locator,
lastFactoryMethod);
}
if (lastFactoryMethod == null)
{
throw new InvalidOperationException($"Not any plugin was able to implement factory for {record.InterfaceType}");
}
return(lastFactoryMethod);
}
private void ComposeParameterRead(ICodeBlockBuilder code, INamedReference readerField, ParameterInfo parameterInfo, INamedReference methodInfoField, INamedReference parameterInfoField, INamedReference contextParameter, INamedReference interceptorField)
{
code.InvokeGenericMethod(
interceptorField,
nameof(IControllerInterceptor.ObtainParameterValue),
new Type[] { parameterInfo.ParameterType },
inv =>
inv.WithParam("this")
.WithParam(methodInfoField)
.WithParam(parameterInfoField)
.WithParam(contextParameter)
.WithParam(
factory =>
factory.Write("() => ")
.InvokeGenericMethod(
readerField,
nameof(IParameterReader.Read),
new Type[] { parameterInfo.ParameterType },
arguments => arguments.WithParam(parameterInfoField).WithParam(contextParameter))));
}
private static IEnumerable <string> GetSourceBranchRegexes(INamedReference branch, Config configuration)
{
var branchName = branch.Name.WithoutRemote;
var currentBranchConfig = configuration.GetConfigForBranch(branchName);
if (currentBranchConfig?.SourceBranches == null)
{
yield return(".*");
}
else
{
foreach (var sourceBranch in currentBranchConfig.SourceBranches)
{
var regex = configuration.Branches[sourceBranch]?.Regex;
if (regex != null)
{
yield return(regex);
}
}
}
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
if (!setup.GetBehavior(s_defaultBehavior).Dispose)
{
return(previousPluginMethod);
}
var method = locatorBuilder.HasMethod($"Dispose{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_{Guid.NewGuid():N}")
.Returns(setup.InterfaceType);
method.Body.Write("return ")
.Invoke("TryRegisterDisposable", invocation => invocation.WithParam(p => p.Invoke(previousPluginMethod,
inv => { })))
.EndStatement();
return(method);
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
var behavior = setup.Behaviors.OfType <ControllerBehavior>().FirstOrDefault();
if (behavior == null)
{
return(previousPluginMethod);
}
var indexFactory =
locatorBuilder.HasMethod("GetRoboapiControllerIndexFactory")
.Returns <IEnumerable <KeyValuePair <string, Type> > >()
.WithModifier("private");
indexFactory.Body.Write("yield return new ")
.Write(typeof(KeyValuePair <string, Type>))
.Write("(")
.String(behavior.ControllerName)
.Write(", ")
.Typeof(setup.ImplementingType)
.Write(")")
.EndStatement();
var builder = Activator.CreateInstance(behavior.ProxyBuilderType) as ControllerProxyBuilder;
var proxy = builder.BuildProxyClass(locatorBuilder, setup.ImplementingType, behavior.CallBuilderType);
var factoryMethod =
locatorBuilder.HasMethod($"factory{setup.ImplementingType.Name}").Returns(setup.ImplementingType);
factoryMethod.Body.Write("return new ").Write(proxy).Write("(this)").EndStatement();
return(factoryMethod);
}
public INamedReference GenerateFactoryMethod(
IServiceSetupRecord setup,
Dictionary <string, INamedReference> ctorParamValueFactoryFields,
INamedReference valueFactoryField,
IClassBuilder locatorBuilder,
INamedReference previousPluginMethod)
{
if (setup.GetBehavior(s_defaultBehavior).AlwaysNewInstance)
{
return(previousPluginMethod);
}
var field = locatorBuilder.HasField(setup.InterfaceType).WithModifier("private");
var fMethod = locatorBuilder.HasMethod($"Singleton_{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_{Guid.NewGuid():N}").Returns(setup.InterfaceType);
fMethod.Body.Write(" return ")
.LazyReadOrAssign(field, a => a.Invoke(previousPluginMethod, inv => { }))
.EndStatement();
return(fMethod);
}
public ICodeBlockBuilder LazyReadOrAssign(INamedReference target, Action <ICodeBlockBuilder> assignment)
{
Write("(").Write(target).Write(" ?? (").Write(target).Write(" = ");
assignment(this);
return(Write("))"));
}
public ICodeBlockBuilder Assign(INamedReference target, Action <ICodeBlockBuilder> assignment)
{
Write(target).Write(" = ");
assignment(this);
return(EndStatement());
}
public INamedReference DeclareLocal(string name, INamedReference typeReference)
{
Write(typeReference).Space().Write(name).EndStatement();
return(new NamedReference(name));
}
public ICodeBlockBuilder Write(INamedReference reference)
{
return(Write(reference.Name));
}
public ICodeBlockBuilder Compare(INamedReference a, string b)
{
return(Write(a).Write(" == ").Write(b));
}
public ClassFieldBuilder(string name, INamedReference type, int indent)
: base(name)
{
m_type = type;
m_indent = indent;
}