public static ISenderReceiver GetBuilder(BuilderType type)
{
ISenderReceiver people = null;
switch (type)
{
case BuilderType.Hello:
people = new HelloBuilder();
break;
case BuilderType.Hi:
people = new HiBuilder();
break;
}
return people;
}
public static void ImplementAssignMethodAttribute(Builder builder, AssignMethodAttributeInfo[] assignMethodAttributeInfos, Field interceptorInstance, BuilderType contentType, Coder coder) =>
ImplementAssignMethodAttribute(builder, assignMethodAttributeInfos,
(delegateCtor, method, assignMethodAttributeInfo) => coder.Load(interceptorInstance)
.As(contentType)
.SetValue(assignMethodAttributeInfo.AttributeField, y => y.NewObj(delegateCtor, method.ThisOrNull(), method)));
protected BooleanExpressionCoderBase(BooleanExpressionCoderBase self, BuilderType builderType) : base(self.instructions, self.jumpTargets, builderType)
{
}
internal VariableCoder(InstructionBlock instructionBlock, BuilderType builderType) : base(instructionBlock) => this.builderType = builderType;
CoderBase ICasting.As(BuilderType type) => this.As(type);
internal BooleanExpressionFieldCoder(BooleanExpressionCoderBase coder, BuilderType builderType) : base(coder, builderType)
{
}
static public int AddUnsignedInt(UInt32 dataNum, byte[] dataStream, UInt16 addPos, BuilderType builderType)
{
int retValue = 0;
if (builderType == BuilderType.BYTE)
{
byte _data = (byte)dataNum;
dataStream[addPos] = (byte)(_data & 0xff);
retValue = 1;
}
else if (builderType == BuilderType.INT16_BYTE)
{
UInt16 _data = (UInt16)dataNum;
dataStream[addPos] = (byte)(_data & 0xff);
dataStream[addPos + 1] = (byte)((_data >> 8) & 0xff);
retValue = 2;
}
else if (builderType == BuilderType.INT32_BYTE)
{
UInt32 _data = (UInt32)dataNum;
dataStream[addPos] = (byte)(_data & 0xff);
dataStream[addPos + 1] = (byte)((_data >> 8) & 0xff);
dataStream[addPos + 2] = (byte)((_data >> 16) & 0xff);
dataStream[addPos + 3] = (byte)((_data >> 24) & 0xff);
retValue = 4;
}
return(retValue);
}
internal FieldCoder(InstructionBlock instructionBlock, BuilderType builderType) : base(instructionBlock) => this.builderType = builderType;
public static Field GetChanged(BuilderType builderType) => builderType.GetField("Changed", false);
//foreach (EbControl control in Controls)
//{
// if (control is EbControlContainer)
// {
// EbControlContainer Cont = control as EbControlContainer;
// if (Cont.TableName.IsNullOrEmpty()|| Cont.TableName.Trim() == string.Empty)
// {
// Cont.TableName = TableName;
// }
// }
//}
//public virtual string GetSelectQuery(string _parentTblName)
//{
// string ColoumsStr = Get1stLvlColNames();
// string qry = string.Empty;
// if (ColoumsStr.Length > 0)
// {
// if (TableName == _parentTblName)
// qry = string.Format("SELECT id, {0} FROM {1} WHERE {3} = {2};", ColoumsStr, TableName, TableRowId, "id");
// else
// qry = string.Format("SELECT id, {0} FROM {1} WHERE {3}={2};", ColoumsStr, TableName, TableRowId, _parentTblName + "_id");
// }
// foreach (EbControl control in Controls)
// {
// if (control is EbControlContainer)
// {
// EbControlContainer _control = (control as EbControlContainer);
// if (_control.TableName.IsNullOrEmpty())
// {
// _control.TableName = TableName;
// }
// //_control.TableName = _control.TableName.IsNullOrEmpty() ? TableName : _control.TableName;
// _control.TableRowId = (_control.TableRowId == 0) ? TableRowId : _control.TableRowId;
// qry += _control.GetSelectQuery(_parentTblName);
// }
// }
// return qry;
//}
public static string GetControlOpsJS(EbControlContainer ebControlContainer, BuilderType FormTypeEnum)
{
string JSCode = "var ControlOps = {}";
Type[] _typeArray = (ebControlContainer.GetType().GetTypeInfo().Assembly.GetTypes());
Dictionary <string, string> DictControlOps = new Dictionary <string, string>();
foreach (Type ctrlType in _typeArray)
{
try
{
TypeInfo _typeInfo = ctrlType.GetTypeInfo();
var _enableInBuider = _typeInfo.GetCustomAttribute <EnableInBuilder>();
string TypeName = ctrlType.Name.Substring(2, ctrlType.Name.Length - 2);
if (_enableInBuider != null && _enableInBuider.BuilderTypes.Contains(FormTypeEnum))
{
object ctrlObj = Activator.CreateInstance(ctrlType);
if (
//(!_typeInfo.IsDefined(typeof(HideInToolBox))) && // temp
ctrlObj is EbControl)
{
if (!DictControlOps.ContainsKey(TypeName))
{
EbControl _ctrlObj = (ctrlObj as EbControl);
string opFnsJs = string.Empty;
opFnsJs += GetOpFnJs("getValue", _ctrlObj.GetValueJSfn, TypeName);
opFnsJs += GetOpFnJs("getValueFromDOM", _ctrlObj.GetValueFromDOMJSfn, TypeName);
opFnsJs += GetOpFnJs("getDisplayMember", _ctrlObj.GetDisplayMemberJSfn, TypeName);
opFnsJs += GetOpFnJs("getDisplayMemberFromDOM", _ctrlObj.GetDisplayMemberFromDOMJSfn, TypeName);
opFnsJs += GetOpFnJs("isRequiredOK", _ctrlObj.IsRequiredOKJSfn, TypeName);
opFnsJs += GetOpFnJs("isEmpty", _ctrlObj.IsEmptyJSfn, TypeName);
opFnsJs += GetOpFnJs("setValue", _ctrlObj.SetValueJSfn, TypeName);
opFnsJs += GetOpFnJs("setDisplayMember", _ctrlObj.SetDisplayMemberJSfn, TypeName);
opFnsJs += GetOpFnJs("justSetValue", _ctrlObj.JustSetValueJSfn, TypeName);
opFnsJs += GetOpFnJs("hide", _ctrlObj.HideJSfn, TypeName);
opFnsJs += GetOpFnJs("show", _ctrlObj.ShowJSfn, TypeName);
opFnsJs += GetOpFnJs("enable", _ctrlObj.EnableJSfn, TypeName);
opFnsJs += GetOpFnJs("disable", _ctrlObj.DisableJSfn, TypeName);
opFnsJs += GetOpFnJs("reset", _ctrlObj.ResetJSfn, TypeName);
opFnsJs += GetOpFnJs("refresh", _ctrlObj.RefreshJSfn, TypeName);
opFnsJs += GetOpFnJs("clear", _ctrlObj.ClearJSfn, TypeName);
opFnsJs += GetOpFnJs("addInvalidStyle", _ctrlObj.AddInvalidStyleJSFn, TypeName);
opFnsJs += GetOpFnJs("removeInvalidStyle", _ctrlObj.RemoveInvalidStyleJSFn, TypeName);
opFnsJs += GetOpFnJs("bindOnChange", _ctrlObj.OnChangeBindJSFn, TypeName);
if (_ctrlObj.ObjType == "DGPowerSelectColumn")
{
opFnsJs += GetOpFnJs("getColumn", _ctrlObj.GetColumnJSfn, TypeName);
}
string fn = string.Concat("function ", TypeName, "(jsonObj){ $.extend(this, jsonObj);", opFnsJs, "}");//.RemoveCR();
JSCode += string.Concat(@"
ControlOps.", TypeName, " = ", fn);;
DictControlOps.Add(TypeName, "fn placeholder");
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
return(JSCode);
}
/// <summary>
/// Makes the transformer builder following the specified builder type.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <param name="type">The builder type to use.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException">Builder type not implemented by now.</exception>
public ITransformerBuilder <TSource, TDestination> MakeTransformerBuilder <TSource, TDestination>(BuilderType type)
where TSource : class
where TDestination : class
{
switch (type)
{
case BuilderType.DefaultMappers:
return(new TransformerBuilder <TSource, TDestination>(this, FactoryMapper.GetDefaultPropertyMappers <TSource, TDestination>()));
case BuilderType.Empty:
return(new TransformerBuilder <TSource, TDestination>(this));
case BuilderType.DynamicResolver:
return(new TransformerBuilder <TSource, TDestination>(this, FactoryMapper.GetDefaultPropertyMappers <TSource, TDestination>(this)));
default:
throw new NotImplementedException("Builder type not implemented by now.");
}
}
private static AssignMethodAttributeInfo[] GetAllAssignMethodAttributedFields(Method attributedMethod, BuilderCustomAttribute builderCustomAttribute, BuilderType targetType, string name, string returnTypeName)
{
var fields = builderCustomAttribute.Type
.GetAttributedFields()
.Where(x => x.Field.IsPublic && !x.Field.IsStatic && x.Attribute.Fullname == __AssignMethodAttribute.Type.Fullname)
.Select(x => x.Import());
if (!fields.Any())
{
return(new AssignMethodAttributeInfo[0]);
}
return(fields
.Select(x =>
{
var throwError = !(bool)x.Attribute.ConstructorArguments[1].Value;
return new AssignMethodAttributeInfo
{
AttributeField = x.Field,
TargetMethodName = ReplacePlaceHolder(targetType.Builder, x.Attribute.ConstructorArguments[0].Value as string ?? "", name, returnTypeName, builderCustomAttribute, throwError),
TargetMethodReturnType = GetDelegateType(x.Field.FieldType),
ThrowError = throwError,
Type = targetType,
ParameterTypes = GetParameters(x.Field.FieldType),
AttributedMethod = attributedMethod
};
}).ToArray());
}
private Method CreateAssigningMethod(BuilderType anonSource, BuilderType anonTarget, BuilderType anonTargetInterface, Method method)
{
var name = $"<{counter++}>f__Anon_Assign";
var assignMethod = method.DeclaringType.CreateMethod(Modifiers.PrivateStatic, anonTarget, name, anonSource);
assignMethod.NewCode()
.Context(x =>
{
var resultVar = x.GetReturnVariable();
x.Assign(resultVar).Set(x.NewCode().NewObj(anonTarget.ParameterlessContructor));
foreach (var property in anonSource.Properties)
{
try
{
var targetProperty = anonTarget.GetProperty(property.Name);
if (property.ReturnType.Fullname != targetProperty.ReturnType.Fullname)
{
this.LogError($"The property '{property.Name}' in '{method.Name}' in type '{method.DeclaringType.Name}' does not have the expected return type. Is: {property.ReturnType.Fullname} Expected: {targetProperty.ReturnType.Fullname}");
continue;
}
x.Load(resultVar).Callvirt(targetProperty.Setter, x.NewCode().Load(x.GetParameter(0)).Callvirt(property.Getter));
}
catch (MethodNotFoundException)
{
this.LogWarning($"The property '{property.Name}' does not exist in '{anonTarget.Name}'");
}
}
x.Load(resultVar).Return();
})
.Replace();
assignMethod.CustomAttributes.AddEditorBrowsableAttribute(EditorBrowsableState.Never);
return(assignMethod);
}
public static void Implement(Builder builder)
{
builder.Log(LogTypes.Info, "Creating Cauldron Cache");
var cauldron = builder.GetType("CauldronInterceptionHelper", SearchContext.Module);
var componentAttribute = BuilderTypes.ComponentAttribute;
var genericComponentAttribute = BuilderTypes.GenericComponentAttribute;
// Before we start let us find all factoryextensions and add a component attribute to them
var factoryResolverInterface = (BuilderType)BuilderTypes.IFactoryExtension;
AddComponentAttribute(builder, builder.FindTypesByInterface(factoryResolverInterface), x => factoryResolverInterface);
// Get all Components
var componentTypes = new List <BuilderType>();
var components = builder
.FindTypesByAttribute(componentAttribute)
.Concat(builder
.CustomAttributes
.Where(x => x.Type == genericComponentAttribute)
.Select(x => new
{
Attribute = BuilderCustomAttribute.Create(componentAttribute, x.ConstructorArguments.Skip(1)),
Type = (x.ConstructorArguments[0].Value as TypeReference).ToBuilderType()
})
.Where(x =>
{
if (x.Type.IsAbstract)
{
builder.Log(LogTypes.Error, $"The GenericComponentAttribute does not support abstract types.");
return(false);
}
if (x.Type.IsInterface)
{
builder.Log(LogTypes.Error, $"The GenericComponentAttribute does not support interfaces.");
return(false);
}
if (x.Type.IsValueType)
{
builder.Log(LogTypes.Error, $"The GenericComponentAttribute does not support value types.");
return(false);
}
return(true);
})
.Select(x => new AttributedType(x.Type, x.Attribute)));
foreach (var component in components)
{
var factoryType = FactoryTypeInfoWeaver.Create(component);
componentTypes.Add(factoryType);
}
builder.Log(LogTypes.Info, "Adding component IFactoryCache Interface");
var linqEnumerable = builder.GetType("System.Linq.Enumerable", SearchContext.AllReferencedModules);
var ifactoryTypeInfo = BuilderTypes.IFactoryTypeInfo.BuilderType.Import().MakeArray();
var getComponentsFromOtherAssemblies = builder.ReferencedAssemblies
.Select(x => x.MainModule.GetType("CauldronInterceptionHelper"))
.Where(x => x != null)
.Select(x => x.ToBuilderType())
.Select(x => x.GetMethod("GetComponents", false)?.Import())
.Where(x => x != null)
.ToArray();
var getComponentsMethod = cauldron.CreateMethod(Modifiers.Public | Modifiers.Static, ifactoryTypeInfo, "GetComponents");
var componentsField = cauldron.CreateField(Modifiers.PrivateStatic, ifactoryTypeInfo, "<FactoryType>f__components");
getComponentsMethod
.NewCoder()
.NewCoder()
.Context(context =>
{
context.If(x => x.Load(componentsField).IsNotNull(), then => then.Load(componentsField).Return());
var resultValue = context.GetOrCreateReturnVariable();
context.SetValue(resultValue, x => x.Newarr(BuilderTypes.IFactoryTypeInfo, componentTypes.Count));
for (int i = 0; i < componentTypes.Count; i++)
{
context
.Load(resultValue)
.StoreElement(context.NewCoder().NewObj(componentTypes[i].ParameterlessContructor), i);
}
context.SetValue(componentsField, resultValue);
return(context.Load(resultValue).Return());
})
.Replace();
var voidMain = builder.GetMain();
if (voidMain != null)
{
voidMain.NewCoder()
.Context(context =>
{
context.Call(builder.GetType("Cauldron.Activator.FactoryCore").GetMethod("SetComponents", 1, true), x => x.Call(getComponentsMethod));
if (getComponentsFromOtherAssemblies.Length > 0)
{
foreach (var item in getComponentsFromOtherAssemblies)
{
context.Call(builder.GetType("Cauldron.Activator.FactoryCore").GetMethod("SetComponents", 1, true), x => x.Call(item));
}
}
return(context);
})
.End
.Insert(InsertionPosition.Beginning);
}
var injectAttribute = new BuilderType[] { builder.GetType("Cauldron.Activator.InjectAttribute") };
var properties = builder.FindPropertiesByAttributes(injectAttribute).ToArray();
var fields = builder.FindFieldsByAttributes(injectAttribute).ToArray();
ImplementInjectField(builder, fields);
ImplementInjectProperties(builder, properties);
ReplaceFactoryCreate(builder);
}
private void CreateComponentCache(Builder builder, BuilderType cauldron)
{
var componentAttribute = __ComponentAttribute.Instance;
var componentConstructorAttribute = __ComponentConstructorAttribute.Type;
var factory = __Factory.Instance;
// Before we start let us find all factoryextensions and add a component attribute to them
var factoryResolverInterface = __IFactoryResolver.Type;
this.AddComponentAttribute(builder, builder.FindTypesByInterface(factoryResolverInterface), x => factoryResolverInterface.Fullname);
// Also the same to all types that inherits from Factory<>
var factoryGeneric = __Factory_1.Type;
this.AddComponentAttribute(builder, builder.FindTypesByBaseClass(factoryGeneric), type =>
{
var factoryBase = type.BaseClasses.FirstOrDefault(x => x.Fullname.StartsWith("Cauldron.Activator.Factory"));
if (factoryBase == null)
{
return(type.Fullname);
}
return(factoryBase.GetGenericArgument(0).Fullname);
});
int counter = 0;
var arrayAvatar = builder.GetType("System.Array").New(x => new
{
Length = x.GetMethod("get_Length")
});
var extensionAvatar = builder.GetType("Cauldron.ExtensionsReflection").New(x => new
{
CreateInstance = x.GetMethod("CreateInstance", 2)
});
var factoryCacheInterface = builder.GetType("Cauldron.Activator.IFactoryCache");
var factoryTypeInfoInterface = builder.GetType("Cauldron.Activator.IFactoryTypeInfo");
var createInstanceInterfaceMethod = factoryTypeInfoInterface.GetMethod("CreateInstance", 1);
// Get all Components
var components = builder.FindTypesByAttribute(componentAttribute.ToBuilderType);
var componentTypes = new List <BuilderType>();
// Create types with the components properties
foreach (var component in components)
{
this.Log("Hardcoding component factory .ctor: " + component.Type.Fullname);
var componentType = builder.CreateType("", TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, $"<>f__IFactoryTypeInfo_{component.Type.Name}_{counter++}");
var componentAttributeField = componentType.CreateField(Modifiers.Private, componentAttribute.ToBuilderType, "componentAttribute");
componentType.AddInterface(factoryTypeInfoInterface);
componentTypes.Add(componentType);
// Create ctor
componentType
.CreateConstructor()
.NewCode()
.Context(x =>
{
x.Load(Crumb.This).Call(builder.GetType(typeof(object)).Import().ParameterlessContructor.Import());
x.Assign(componentAttributeField).NewObj(component);
})
.Return()
.Replace();
// Implement the methods
componentType.CreateMethod(Modifiers.Public | Modifiers.Overrrides, createInstanceInterfaceMethod.ReturnType, createInstanceInterfaceMethod.Name, createInstanceInterfaceMethod.Parameters)
.NewCode()
.Context(x =>
{
var localVariable = x.GetReturnVariable();
// Find any method with a componentcontructor attribute
var ctors = component.Type.GetMethods(y =>
{
if (y.Name == ".cctor")
{
return(true);
}
if (!y.Resolve().IsPublic || !y.Resolve().IsAssembly)
{
return(false);
}
if (y.Name == ".ctor" && y.DeclaringType.FullName.GetHashCode() != component.Type.Fullname.GetHashCode() && y.DeclaringType.FullName != component.Type.Fullname)
{
return(false);
}
if (y.Name.StartsWith("set_"))
{
return(false);
}
return(true);
})
.Where(y => y.CustomAttributes.HasAttribute(componentConstructorAttribute))
.Concat(
component.Type.GetAllProperties().Where(y => y.CustomAttributes.HasAttribute(componentConstructorAttribute))
.Select(y =>
{
y.CustomAttributes.Remove(componentConstructorAttribute);
y.CustomAttributes.AddEditorBrowsableAttribute(EditorBrowsableState.Never);
return(y.Getter);
})
)
.OrderBy(y => y.Parameters.Length)
.ToArray();
if (ctors.Length > 0)
{
bool parameterlessCtorAlreadyHandled = false;
for (int index = 0; index < ctors.Length; index++)
{
this.Log("- " + ctors[index].Fullname);
var ctor = ctors[index];
// add a EditorBrowsable attribute
ctor.CustomAttributes.AddEditorBrowsableAttribute(EditorBrowsableState.Never);
var ctorParameters = ctor.Parameters;
if (ctorParameters.Length > 0)
{
// In this case we have to find a parameterless constructor first
if (component.Type.ParameterlessContructor != null && !parameterlessCtorAlreadyHandled && component.Type.ParameterlessContructor.IsPublicOrInternal)
{
x.Load(Crumb.GetParameter(0)).IsNull().Then(y => y.NewObj(component.Type.ParameterlessContructor).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
x.Load(Crumb.GetParameter(0)).Call(arrayAvatar.Length).EqualTo(0).Then(y => y.NewObj(component.Type.ParameterlessContructor).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
parameterlessCtorAlreadyHandled = true;
}
var code = x.Load(Crumb.GetParameter(0)).Call(arrayAvatar.Length).EqualTo(ctorParameters.Length);
for (int i = 0; i < ctorParameters.Length; i++)
{
code.And.Load(Crumb.GetParameter(0).UnPacked(i)).Is(ctorParameters[i]);
}
if (ctor.Name == ".ctor")
{
code.Then(y => y.NewObj(ctor, Crumb.GetParameter(0).UnPacked()).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
}
else
{
code.Then(y => y.Call(ctor, Crumb.GetParameter(0).UnPacked()).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
}
}
else
{
if (ctor.Name == ".ctor")
{
x.Load(Crumb.GetParameter(0)).IsNull().Then(y => y.NewObj(ctor).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
x.Load(Crumb.GetParameter(0)).Call(arrayAvatar.Length).EqualTo(0).Then(y => y.NewObj(ctor).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
}
else
{
x.Load(Crumb.GetParameter(0)).IsNull().Then(y => y.Call(ctor).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
x.Load(Crumb.GetParameter(0)).Call(arrayAvatar.Length).EqualTo(0).Then(y => y.Call(ctor).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
}
parameterlessCtorAlreadyHandled = true;
}
}
}
else
{
// In case we don't have constructor with ComponentConstructor Attribute,
// then we should look for a parameterless Ctor
if (component.Type.ParameterlessContructor == null)
{
this.Log(LogTypes.Error, component.Type, $"The component '{component.Type.Fullname}' has no ComponentConstructor attribute or the constructor is not public");
}
else if (component.Type.ParameterlessContructor.IsPublicOrInternal)
{
x.Load(Crumb.GetParameter(0)).IsNull().Then(y => y.NewObj(component.Type.ParameterlessContructor).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
x.Load(Crumb.GetParameter(0)).Call(arrayAvatar.Length).EqualTo(0).Then(y => y.NewObj(component.Type.ParameterlessContructor).Dup().Call(factory.OnObjectCreation, Crumb.This).Return());
this.Log($"The component '{component.Type.Fullname}' has no ComponentConstructor attribute. A parameterless ctor was found and will be used.");
}
}
})
.Context(x => x.Call(extensionAvatar.CreateInstance, component.Type, Crumb.GetParameter(0)).Dup().Call(factory.OnObjectCreation, Crumb.This).Return())
.Return()
.Replace();
// Implement the properties
foreach (var property in factoryTypeInfoInterface.Properties)
{
var propertyResult = componentType.CreateProperty(Modifiers.Public | Modifiers.Overrrides, property.ReturnType, property.Name, true);
propertyResult.BackingField.Remove();
switch (property.Name)
{
case "ContractName":
propertyResult.Getter.NewCode().Call(componentAttributeField, componentAttribute.ContractName).Return().Replace();
break;
case "CreationPolicy":
propertyResult.Getter.NewCode().Call(componentAttributeField, componentAttribute.Policy).Return().Replace();
break;
case "Priority":
propertyResult.Getter.NewCode().Call(componentAttributeField, componentAttribute.Priority).Return().Replace();
break;
case "Type":
propertyResult.Getter.NewCode().Load(component.Type).Return().Replace();
break;
}
}
componentType.CustomAttributes.AddEditorBrowsableAttribute(EditorBrowsableState.Never);
// Also remove the component attribute
component.Attribute.Remove();
}
this.Log("Adding component IFactoryCache Interface");
cauldron.AddInterface(factoryCacheInterface);
var factoryCacheInterfaceAvatar = factoryCacheInterface.New(x => new
{
Components = x.GetMethod("GetComponents")
});
var ctorCoder = cauldron.ParameterlessContructor.NewCode();
cauldron.CreateMethod(Modifiers.Public | Modifiers.Overrrides, factoryCacheInterfaceAvatar.Components.ReturnType, factoryCacheInterfaceAvatar.Components.Name)
.NewCode()
.Context(x =>
{
var resultValue = x.GetReturnVariable();
x.Newarr(factoryTypeInfoInterface, componentTypes.Count).StoreLocal(resultValue);
for (int i = 0; i < componentTypes.Count; i++)
{
var field = cauldron.CreateField(Modifiers.Private, factoryTypeInfoInterface, "<FactoryType>f__" + i);
x.Load(resultValue);
x.StoreElement(factoryTypeInfoInterface, field, i);
// x.StoreElement(factoryTypeInfoInterface,
// x.NewCode().NewObj(componentTypes[i].ParameterlessContructor), i);
ctorCoder.Assign(field).NewObj(componentTypes[i].ParameterlessContructor);
}
})
.Return()
.Replace();
ctorCoder.Insert(InsertionPosition.End);
}
private static void CreateSetterDelegate(Builder builder, Method setterDelegateMethod, BuilderType propertyType,
Func <ICode, ICode> loadValue, Func <ICode, Func <object>, ICode> setValue)
{
var extensions = new __Extensions();
var iList = new __IList();
var setterCode = setterDelegateMethod.NewCode();
if (propertyType.ParameterlessContructor != null && propertyType.ParameterlessContructor.IsPublic)
{
loadValue(setterCode).IsNull().Then(y => setValue(y, () => setterCode.NewCode().NewObj(propertyType.ParameterlessContructor)));
}
// Only this if the property implements idisposable
if (propertyType.Implements(typeof(IDisposable)))
{
setterCode.Call(extensions.TryDisposeInternal, loadValue(setterCode.NewCode()));
}
setterCode.Load(Crumb.GetParameter(0)).IsNull().Then(x =>
{
// Just clear if its clearable
if (propertyType.Implements(__IList.Type.Fullname))
{
loadValue(x).Callvirt(iList.Clear).Return();
}
// Otherwise if the property is not a value type and nullable
else if (!propertyType.IsValueType || propertyType.IsNullable || propertyType.IsArray)
{
setValue(x, () => null).Return();
}
else // otherwise... throw an exception
{
x.ThrowNew(typeof(NotSupportedException), "Value types does not accept null values.");
}
});
if (propertyType.IsArray)
{
setterCode.Load(Crumb.GetParameter(0)).Is(typeof(IEnumerable))
.Then(x => setValue(x, () => Crumb.GetParameter(0)).Return())
.ThrowNew(typeof(NotSupportedException), "Value does not inherits from IEnumerable");
}
else if (propertyType.Implements(__IList.Type.Fullname) && propertyType.ParameterlessContructor != null)
{
var addRange = propertyType.GetMethod("AddRange", 1, false);
if (addRange == null)
{
var add = propertyType.GetMethod("Add", 1);
var array = setterCode.CreateVariable(propertyType.ChildType.MakeArray());
setterCode.Assign(array).Set(Crumb.GetParameter(0));
setterCode.For(array, (x, item) => loadValue(x).Callvirt(add, item));
if (!add.ReturnType.IsVoid)
{
setterCode.Pop();
}
}
else
{
loadValue(setterCode).Callvirt(addRange, Crumb.GetParameter(0));
}
}
else if (propertyType.IsEnum)
{
// Enums requires special threatment
setterCode.Load(Crumb.GetParameter(0)).Is(typeof(string)).Then(x =>
{
var stringVariable = setterCode.CreateVariable(typeof(string));
setterCode.Assign(stringVariable).Set(Crumb.GetParameter(0));
setValue(setterCode, () => stringVariable).Return();
});
setValue(setterCode, () => Crumb.GetParameter(0));
}
else
{
setValue(setterCode, () => Crumb.GetParameter(0));
}
setterCode.Return().Replace();
}
private static void CreateSetterDelegate(Builder builder, Method setterDelegateMethod, BuilderType propertyType, object value)
{
var setterCode = setterDelegateMethod.NewCoder();
T CodeMe <T>(Func <Field, T> fieldCode, Func <Property, T> propertyCode) where T : class
{
switch (value)
{
case Field field: return(fieldCode(field));
case Property property: return(propertyCode(property));
default: return(null);
}
}
if (propertyType.ParameterlessContructor != null && propertyType.ParameterlessContructor.IsPublic)
{
CodeMe(
field => setterCode.If(x => x.Load(field).IsNull(), then => then.SetValue(field, x => x.NewObj(propertyType.ParameterlessContructor))),
property => setterCode.If(x => x.Call(property.Getter).IsNull(), then => then.Call(property.Setter, x => x.NewObj(propertyType.ParameterlessContructor))));
}
// Only this if the property implements idisposable
if (propertyType.Implements(typeof(IDisposable)))
{
CodeMe(
field => setterCode.Call(BuilderTypes.Extensions.GetMethod_TryDisposeInternal(), x => x.Load(field)),
property => setterCode.Call(BuilderTypes.Extensions.GetMethod_TryDisposeInternal(), x => x.Call(property.Getter)));
}
setterCode.If(x => x.Load(CodeBlocks.GetParameter(0)).IsNull(), then =>
{
// Just clear if its clearable
if (propertyType.Implements(BuilderTypes.IList))
{
CodeMe(
field => setterCode.Load(field).Call(BuilderTypes.IList.GetMethod_Clear()).Return(),
property => setterCode.Call(property.Getter).Call(BuilderTypes.IList.GetMethod_Clear()).Return());
}
// Otherwise if the property is not a value type and nullable
else if (!propertyType.IsValueType || propertyType.IsNullable || propertyType.IsArray)
{
CodeMe <CoderBase>(
field => setterCode.SetValue(field, null),
property => setterCode.Call(property.Setter, null));
}
else // otherwise... throw an exception
{
then.ThrowNew(typeof(NotSupportedException), "Value types does not accept null values.");
}
return(then);
});
setterCode.If(x => CodeMe(
field => x.Load(CodeBlocks.GetParameter(0)).Is(field.FieldType),
property => x.Load(CodeBlocks.GetParameter(0)).Is(property.ReturnType)), then =>
CodeMe(
field => then.SetValue(field, CodeBlocks.GetParameter(0)).Return(),
property => then.Call(property.Setter, CodeBlocks.GetParameter(0)).Return()));
if (propertyType.Implements(BuilderTypes.IList))
{
var add = propertyType.GetMethod("Add", 1);
var array = setterDelegateMethod.GetOrCreateVariable(propertyType.ChildType.MakeArray());
setterCode.SetValue(array, CodeBlocks.GetParameter(0));
setterCode.For(array, (x, item, indexer) => CodeMe(
field => x.Load(field).Call(add, item()),
property => x.Call(property.Getter).Call(add, item())));
if (!add.ReturnType.IsVoid)
{
setterCode.Pop();
}
}
else if (propertyType.Implements(typeof(IEnumerable)) || propertyType.IsArray)
{
setterCode.If(x => x.Load(CodeBlocks.GetParameter(0)).Is(typeof(IEnumerable)), then =>
CodeMe(
field => then.SetValue(field, CodeBlocks.GetParameter(0)).Return(),
property => then.Call(property.Setter, CodeBlocks.GetParameter(0)).Return()))
.ThrowNew(typeof(NotSupportedException), "Value does not inherits from IEnumerable");
}
else if (propertyType.IsEnum)
{
// Enums requires special threatment
setterCode.If(x => x.Load(CodeBlocks.GetParameter(0)).Is(typeof(string)),
then =>
{
var stringVariable = setterDelegateMethod.GetOrCreateVariable(typeof(string));
then.SetValue(stringVariable, CodeBlocks.GetParameter(0));
CodeMe( // Cecilator automagically implements a convertion for this
field => then.SetValue(field, stringVariable).Return(),
property => then.Call(property.Setter, stringVariable).Return());
return(then);
});
CodeMe <CoderBase>(
field => setterCode.SetValue(field, CodeBlocks.GetParameter(0)),
property => setterCode.Call(property.Setter, CodeBlocks.GetParameter(0)));
}
else
{
CodeMe <CoderBase>(
field => setterCode.SetValue(field, CodeBlocks.GetParameter(0)),
property => setterCode.Call(property.Setter, CodeBlocks.GetParameter(0)));
}
setterCode.Return().Replace();
}
public IBaseMessage Execute(IPipelineContext pipelineContext, IBaseMessage message)
{
message.ResolvePluginType(BizTalkFactoryProperties.ContextBuilderTypeName, BuilderType)
.AsPlugin <IContextBuilder>()
.IfNotNull(
contextBuilder => {
if (ExecutionMode == PluginExecutionMode.Deferred)
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Scheduling builder plugin '{0}' for deferred execution.", BuilderType.ToString());
}
message.BodyPart.WrapOriginalDataStream(
originalStream => {
var substitutionStream = new EventingReadStream(originalStream);
substitutionStream.AfterLastReadEvent += (src, args) => {
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Executing builder plugin '{0}' that was scheduled for deferred execution.", BuilderType.ToString());
}
contextBuilder.Execute(message.Context);
};
return(substitutionStream);
},
pipelineContext.ResourceTracker);
}
else
{
if (_logger.IsDebugEnabled)
{
_logger.DebugFormat("Executing builder plugin '{0}' that is scheduled for immediate execution.", BuilderType.ToString());
}
contextBuilder.Execute(message.Context);
}
});
return(message);
}
internal BuilderId(YVisibility visibility, BuilderType type)
{
this.visibility = visibility;
this.type = type;
}
static public int AddUnsignedFloat(float dataNum, byte[] dataStream, UInt16 addPos, BuilderType builderType)
{
UInt32 _data = 0;
if (builderType == BuilderType.FLOAT_BYTE_Q8)
{
_data = (UInt32)(dataNum * (1 << 8));
}
else if (builderType == BuilderType.FLOAT_BYTE_Q16)
{
_data = (UInt32)(dataNum * (1 << 16));
}
return(AddUnsignedInt(_data, dataStream, addPos, BuilderType.INT32_BYTE));
}
internal BooleanExpressionVariableCoder(BooleanExpressionCoderBase coder, BuilderType builderType) : base(coder, builderType)
{
}
public BooleanExpressionFieldCoder As(BuilderType type)
{
InstructionBlock.CastOrBoxValues(this, type);
return(new BooleanExpressionFieldCoder(this, type));
}
public CatchCoder Catch(BuilderType exceptionType, Func <CatchThrowerCoder, Func <ExceptionCodeBlock>, Coder> code) => this.CatchInternal(exceptionType, code);
internal FactoryTypeInfoWeaverBase(ComponentAttributeValues componentAttributeValue, BuilderType componentInfoType, Coder componentTypeCtor, BuilderType componentType, (TypeReference childType, bool isSuccessful) childType)
private static Method CreateAssigningMethod(Builder builder, BuilderType anonSource, BuilderType anonTarget, BuilderType anonTargetInterface, Method method)
{
var name = $"<{counter++}>f__Anon_Assign";
var assignMethod = method.OriginType.CreateMethod(Modifiers.PrivateStatic, anonTarget, name, anonSource);
assignMethod.NewCoder()
.Context(context =>
{
var resultVar = context.GetOrCreateReturnVariable();
context.SetValue(resultVar, x => x.NewObj(anonTarget.ParameterlessContructor));
foreach (var property in anonSource.Properties)
{
try
{
var targetProperty = anonTarget.GetProperty(property.Name);
if (property.ReturnType.Fullname != targetProperty.ReturnType.Fullname)
{
builder.Log(LogTypes.Error, property, $"The property '{property.Name}' does not have the expected return type. Is: {property.ReturnType.Fullname} Expected: {targetProperty.ReturnType.Fullname}");
continue;
}
context.Load(resultVar).Call(targetProperty.Setter, x => x.Load(CodeBlocks.GetParameter(0)).Call(property.Getter));
}
catch (MethodNotFoundException)
{
builder.Log(LogTypes.Warning, anonTarget, $"The property '{property.Name}' does not exist in '{anonTarget.Name}'");
}
}
return(context.Load(resultVar).Return());
})
.Replace();
assignMethod.CustomAttributes.AddEditorBrowsableAttribute(EditorBrowsableState.Never);
return(assignMethod);
}
public Field GetIsChangedChanged(BuilderType builderType) => builderType.GetField("IsChangedChanged", false);
private static IEnumerable <Method> GetValidMethods(DecoratorDecription decorator, BuilderType[] methodParameters, BuilderType @class)
{
return(@class.Methods.Where(x =>
{
if (x.IsPropertyGetterSetter)
{
return false;
}
if (!decorator.TargetMethodFilter.Static && x.IsStatic)
{
return false;
}
if (!decorator.TargetMethodFilter.Instanced && !x.IsStatic)
{
return false;
}
if (
decorator.TargetMethodFilter.Protected && !x.IsProtected &&
decorator.TargetMethodFilter.Public && !x.IsPublic &&
decorator.TargetMethodFilter.Private && !x.IsPrivate &&
decorator.TargetMethodFilter.Internal && !x.IsInternal)
{
return false;
}
if (decorator.TargetMethodFilter.ReturnTypeNames.Length > 0 && !decorator.TargetMethodFilter.ReturnTypeNames.Any(y => y == x.Fullname))
{
return false;
}
if (decorator.TargetMethodFilter.ParameterMatch)
{
if (!decorator.TargetMethodFilter.ParameterStrict && decorator.TargetMethodFilter.Parameters.Length > 0 && !x.Parameters.AreReferenceAssignable(methodParameters))
{
return false;
}
else if (decorator.TargetMethodFilter.ParameterStrict && decorator.TargetMethodFilter.Parameters.Length > 0 && !x.Parameters.SequenceEqual(methodParameters))
{
return false;
}
}
if (x.IsGenerated)
{
return false;
}
if (!string.IsNullOrEmpty(decorator.TargetMethodFilter.Name) && !Regex.IsMatch(x.Name, decorator.TargetMethodFilter.Name == "*" ? "[a-zA-Z].*" : decorator.TargetMethodFilter.Name, RegexOptions.Singleline))
{
return false;
}
return true;
}));
}
public static void ImplementAssignMethodAttribute(Builder builder, AssignMethodAttributeInfo[] assignMethodAttributeInfos, CecilatorBase cecilatorBase, BuilderType contentType, Coder coder)
{
switch (cecilatorBase)
{
case Field field:
ImplementAssignMethodAttribute(builder, assignMethodAttributeInfos, field, contentType, coder);
break;
case LocalVariable variable:
ImplementAssignMethodAttribute(builder, assignMethodAttributeInfos, variable, contentType, coder);
break;
default:
throw new NotImplementedException("This is only available for Field and LocalVariable");
}
}
private static IEnumerable <Property> GetValidProperties(DecoratorDecription decorator, BuilderType @class)
{
return(@class.Properties.Where(x =>
{
if (!decorator.TargetPropertyFilter.Static && x.IsStatic)
{
return false;
}
if (!decorator.TargetPropertyFilter.Instanced && !x.IsStatic)
{
return false;
}
if (
decorator.TargetPropertyFilter.Protected && !x.IsProtected &&
decorator.TargetPropertyFilter.Public && !x.IsPublic &&
decorator.TargetPropertyFilter.Private && !x.IsPrivate &&
decorator.TargetPropertyFilter.Internal && !x.IsInternal)
{
return false;
}
if (decorator.TargetPropertyFilter.ReturnTypeNames.Length > 0 && !decorator.TargetPropertyFilter.ReturnTypeNames.Any(y => y == x.ReturnType.Fullname))
{
return false;
}
if (x.IsGenerated)
{
return false;
}
if (!string.IsNullOrEmpty(decorator.TargetPropertyFilter.Name) && !Regex.IsMatch(x.Name, decorator.TargetMethodFilter.Name == "*" ? "[a-zA-Z].*" : decorator.TargetPropertyFilter.Name, RegexOptions.Singleline))
{
return false;
}
return true;
}));
}
public Field GetField(BuilderType builderType) => builderType.GetField(this.Name, true).Import();
public static bool IsIEnumerable(this BuilderType builderType) => BuilderTypes .IEnumerable .BuilderType .AreReferenceAssignable(builderType) || builderType.IsArray;
