private static Type CreateType(IDictionary <ITypeDescription, Type> typeBuildMap, ModuleBuilder modBuilder, ITypeDescription typeInfo) { return(typeInfo.TryResolveType(t => GetOrCreateType(typeBuildMap, modBuilder, t)) .Convert(t => AddNativeType(typeInfo, t, typeBuildMap)) .GetValue(() => AddNoNativeType(typeInfo, typeBuildMap, modBuilder))); }
public ITypeData CreateTypeData(ITypeDescription description) { return(new TypeData() { AssemblyName = description.AssemblyName, Name = description.Name, Namespace = description.Namespace }); }
private static Type FindType(ITypeDescription typeInfo, Assembly candidateAssembly) { return(typeInfo.TryResolveType(n => FindType(n, candidateAssembly)) .Convert(t => t) .GetValue( () => FindTypeOrArray(typeInfo, candidateAssembly))); }
internal static bool IsBusinessType(ITypeDescription description) { var name = description.TypeName.FullName; return !description.IsArray && !name.StartsWith("System.") && !name.StartsWith("Db4objects."); }
internal static IEnumerable <ITypeDescription> CreateSingleFieldClass(ITypeDescription fieldType) { var type = SimpleClassDescription.Create(SingleFieldType(), f => CreateField(fieldType)); return(new[] { type, StringType }); }
private static Type BuildMetaInfoType(ModuleBuilder moduleBuilder, ITypeDescription type) { var typeBuilder = moduleBuilder.DefineType(MetaDataNameSpace + "." + CodeGenerationUtils.ClassName(type.TypeName), CodeGenerationUtils.PublicClass()); AddNameProperty(typeBuilder, type); return(typeBuilder.CreateType()); }
public static IEnumerable<ITypeDescription> CreateClassListGenericOf(ITypeDescription typeOfLists) { var listType = KnownType.Create(typeof (List<>), new[]{typeOfLists}); var type = SimpleClassDescription.Create(SingleFieldType(), f => CreateField(listType)); return new[] { type, listType, typeOfLists }; }
private SimpleFieldDescription(string fieldName, ITypeDescription type, IndexingState indexState) { this.Name = fieldName; this.Type = type; IsBackingField = IsNameBackingField(fieldName); IndexingState = indexState; }
internal static bool IsBusinessType(ITypeDescription description) { var name = description.TypeName.FullName; return(!description.IsArray && !name.StartsWith("System.") && !name.StartsWith("Db4objects.")); }
private SimpleFieldDescription(string fieldName, ITypeDescription type,IndexingState indexState) { this.Name = fieldName; this.Type = type; IsBackingField = IsNameBackingField(fieldName); IndexingState = indexState; }
public static IEnumerable <ITypeDescription> CreateClassListGenericOf(ITypeDescription typeOfLists) { var listType = KnownType.Create(typeof(List <>), new[] { typeOfLists }); var type = SimpleClassDescription.Create(SingleFieldType(), f => CreateField(listType)); return(new[] { type, listType, typeOfLists }); }
public DefaultFallbackCreator(ModuleBuilder moduleBuilder, ITypeDescription description) { _moduleBuilder = moduleBuilder; _description = description; var compiler = new FallbackCompiler(moduleBuilder, description); _factoryMethod = compiler.Compile(); }
public IGeneratedType GenerateType(ITypeDescription typeDescription) { if (typeDescription == null) { throw new ArgumentNullException("typeDescription"); } return(this.GenerateTypes(new[] { typeDescription }).Where(x => x.Name == typeDescription.Name).Single()); }
public TimeoutProxyCreator(ModuleBuilder moduleBuilder, ITypeDescription typeDescription) { _moduleBuilder = moduleBuilder; _typeDescription = typeDescription; var compiler = new TimeoutProxyCompiler(moduleBuilder, typeDescription); _factoryMethod = compiler.Compile(); }
private static void CreateQueryGetter(MethodBuilder getterMethod, Type type, ITypeDescription typeDescription) { var ilGenerator = getterMethod.GetILGenerator(); ilGenerator.Emit(OpCodes.Call, StaticQueryCall(type)); ilGenerator.Emit(OpCodes.Ret); }
private void CreateMetaDataGetter(MethodBuilder getterMethod, Type type, ITypeDescription typeDescription) { var returnType = getterMethod.ReturnType; CodeGenerationUtils.ReturnNewInstanceILInstructions( returnType.GetConstructors().Single(), getterMethod); }
public FallbackCompiler(ModuleBuilder moduleBuilder, ITypeDescription interfaceDescription) { _interfaceType = typeof(T); var proxyTypeName = string.Format("SharpRemote.FaultTolerance.DefaultFallback.{0}", _interfaceType.FullName); _typeBuilder = moduleBuilder.DefineType(proxyTypeName, TypeAttributes.Sealed | TypeAttributes.Class); _typeBuilder.AddInterfaceImplementation(interfaceDescription.Type); _interfaceDescription = interfaceDescription; }
private string NameOfProperty(ITypeDescription typeDescription) { var name = typeDescription.TypeName.NameWithGenerics.Split('.').Last().Replace('+', '_'); if (needsAssemblyInName.Contains(typeDescription)) { return(name + "_" + CodeGenerationUtils.NormalizedAssemblyName(typeDescription.TypeName)); } return(name); }
protected override void EmitReadEnum(ILGenerator gen, ITypeDescription typeDescription) { // TODO: Benchmark and optimize this shit code (there's really no need for any allocation) // Using a switch statement or a dictionary lookup would be much more preferrable gen.Emit(OpCodes.Ldtoken, typeDescription.Type); gen.Emit(OpCodes.Call, Methods.TypeGetTypeFromHandle); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Call, XmlSerializerReadString); gen.Emit(OpCodes.Call, EnumParse); gen.Emit(OpCodes.Unbox_Any, typeDescription.Type); }
private static ExplorerItem ToTypeExplorerItem(ITypeDescription typeDescription, bool includeAssemblyName) { var name = typeDescription.Name + (includeAssemblyName ? "_" + CodeGenerationUtils.NormalizedAssemblyName(typeDescription.TypeName) : ""); return(new ExplorerItem(name, ExplorerItemKind.QueryableObject, ExplorerIcon.Table) { Children = Fields(Maybe.From(typeDescription)) }); }
public AsyncStateMachineCompiler(TypeBuilder typeBuilder, ITypeDescription interfaceDescription, IMethodDescription methodDescription) { _originalMethod = methodDescription.Method; var taskType = methodDescription.ReturnType.Type; _taskGetAwaiter = taskType.GetMethod(nameof(Task.GetAwaiter)); _awaiterType = GetAwaiterType(taskType); _awaiterOnCompleted = _awaiterType.GetMethod(nameof(TaskAwaiter.OnCompleted), new[] { typeof(Action) }); var taskReturnType = GetTaskReturnType(taskType); _hasReturnValue = taskReturnType != typeof(void); if (_hasReturnValue) { _taskGetResult = taskType.GetProperty(nameof(Task <int> .Result)).GetMethod; } var interfaceType = interfaceDescription.Type; _taskCompletionSourceType = GetTaskCompletionSourceType(taskType); _taskCompletionSourceSetResult = _taskCompletionSourceType.GetMethod(nameof(TaskCompletionSource <int> .SetResult)); _taskCompletionSourceSetException = _taskCompletionSourceType.GetMethod(nameof(TaskCompletionSource <int> .SetException), new [] { typeof(Exception) }); _taskCompletionSourceSetExceptions = _taskCompletionSourceType.GetMethod(nameof(TaskCompletionSource <int> .SetException), new [] { typeof(IEnumerable <Exception>) }); _taskCompletionSourceGetTask = _taskCompletionSourceType.GetProperty(nameof(TaskCompletionSource <int> .Task)) .GetMethod; var name = string.Format("{0}_AsyncStateMachine", methodDescription.Name); _stateMachine = typeBuilder.DefineNestedType(name); _subject = _stateMachine.DefineField("Subject", taskType, FieldAttributes.Public); _fallback = _stateMachine.DefineField("Fallback", interfaceType, FieldAttributes.Public); _subjectTask = _stateMachine.DefineField("_subjectTask", taskType, FieldAttributes.Private); _fallbackTask = _stateMachine.DefineField("_fallbackTask", taskType, FieldAttributes.Private); _taskCompletionSource = _stateMachine.DefineField("TaskCompletionSource", _taskCompletionSourceType, FieldAttributes.Public | FieldAttributes.InitOnly); _parameters = new List <FieldInfo>(methodDescription.Parameters.Count); foreach (var parameter in methodDescription.Parameters) { var parameterName = string.Format("parameter_{0}", parameter.Name); var field = _stateMachine.DefineField(parameterName, parameter.ParameterType.Type, FieldAttributes.Public); _parameters.Add(field); } }
private TypeBuilder FindLocationForProperty(ByNameGrouping type, ITypeDescription forType) { if (type.HasMultipleValues) { var typeNameSeparation = forType.TypeName.NameAndNamespace.LastIndexOf('.'); var namespaceName = forType.TypeName.NameAndNamespace.Substring(0, typeNameSeparation); return(GetOrCreateNamespaceFor(namespaceName)); } return(rootType); }
private bool Equals(ITypeDescription other) { if (ReferenceEquals(null, other)) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return(Equals(other.TypeName, TypeName)); }
protected override void EmitWriteEnum(ILGenerator gen, ITypeDescription typeDescription, Action loadMember, Action loadMemberAddress) { // TODO: Benchmark and optimize this shit code (there's really no need for any allocation) // Using a switch statement or a dictionary lookup would be much more preferrable gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldtoken, typeDescription.Type); gen.Emit(OpCodes.Call, Methods.TypeGetTypeFromHandle); loadMember(); gen.Emit(OpCodes.Box, typeDescription.Type); gen.Emit(OpCodes.Call, EnumGetName); gen.Emit(OpCodes.Call, XmlSerializerWriteString); }
private static void AddNameProperty(TypeBuilder typeBuilder, ITypeDescription type) { AddLabelProperty(typeBuilder, "ClassName", type.Name); AddLabelProperty(typeBuilder, "ClassFullName", type.TypeName.FullName); foreach (var field in type.Fields) { AddLabelProperty(typeBuilder, field.AsPropertyName(), NameWithIndexState(field.Name, field.IndexingState)); if (!field.IsBackingField) { AddLabelProperty(typeBuilder, field.Name, NameWithIndexState(field.Name, field.IndexingState)); } } }
private static void ThrowIfIncompatible(ITypeDescription expectedDescription, TypeDescription actualDescription) { foreach (var expectedMethod in expectedDescription.Methods) { var actualMethod = actualDescription.Methods.FirstOrDefault(x => x.Name == expectedMethod.Name); if (actualMethod == null) { throw new NotImplementedException($"The remote is missing interface method: {expectedDescription.Type.Name}.{expectedMethod.Name}"); } ThrowIfIncompatible(expectedMethod, actualMethod); } }
private static void AddNameProperty(TypeBuilder typeBuilder, ITypeDescription type) { AddLabelProperty(typeBuilder, "ClassName", type.Name); AddLabelProperty(typeBuilder, "ClassFullName", type.TypeName.FullName); foreach (var field in type.Fields) { AddLabelProperty(typeBuilder, field.AsPropertyName(), NameWithIndexState(field.Name, field.IndexingState)); if(!field.IsBackingField) { AddLabelProperty(typeBuilder, field.Name, NameWithIndexState(field.Name,field.IndexingState)); } } }
public FallbackProxyCompiler(ModuleBuilder moduleBuilder, ITypeDescription interfaceDescription) { _interfaceType = typeof(T); var proxyTypeName = string.Format("SharpRemote.FaultTolerance.Fallback.{0}", _interfaceType.FullName); _typeBuilder = moduleBuilder.DefineType(proxyTypeName, TypeAttributes.Sealed | TypeAttributes.Class); _typeBuilder.AddInterfaceImplementation(interfaceDescription.Type); _interfaceDescription = interfaceDescription; _subject = _typeBuilder.DefineField("_subject", _interfaceType, FieldAttributes.InitOnly | FieldAttributes.Private); _fallback = _typeBuilder.DefineField("_fallback", _interfaceType, FieldAttributes.InitOnly | FieldAttributes.Private); }
private static void GetTypeConstraints(XmlNode xmlNode, ITypeDescription colDesc) { var constraintName = xmlNode.Name; var opName = xmlNode.Attributes?["Operator"].InnerText; if (opName == "in") { var constraintValues = xmlNode.InnerText.Split(',').Select(v => Convert.ToInt32(v)); colDesc.AddConstraint(constraintName, opName, constraintValues); } else { var constraintValue = Convert.ToInt32(xmlNode.InnerText); colDesc.AddConstraint(constraintName, opName, constraintValue); } }
private XmlMethodsCompiler(TypeBuilder typeBuilder, ITypeDescription typeDescription, CompilationContext context, XmlWriteValueMethodCompiler writeValueMethodCompiler, XmlWriteObjectMethodCompiler writeObjectMethodCompiler, XmlReadValueMethodCompiler readValueMethodCompiler, XmlReadObjectMethodCompiler readObjectMethodCompiler) : base(typeBuilder, typeDescription, writeValueMethodCompiler, writeObjectMethodCompiler, readValueMethodCompiler, readObjectMethodCompiler) { _context = context; }
public BinaryMethodsCompiler(TypeBuilder typeBuilder, ITypeDescription typeDescription, CompilationContext context, BinaryWriteValueMethodCompiler writeValueMethodCompiler, BinaryWriteObjectMethodCompiler writeObjectMethodCompiler, BinaryReadValueMethodCompiler readValueMethodCompiler, BinaryReadObjectMethodCompiler readObjectMethodCompiler) : base(typeBuilder, typeDescription, writeValueMethodCompiler, writeObjectMethodCompiler, readValueMethodCompiler, readObjectMethodCompiler) { _context = context; }
private static Type BuildEnum(ITypeDescription typeInfo, IDictionary<ITypeDescription, Type> typeBuildMap, ModuleBuilder modBuilder) { var enumBuilder = modBuilder.DefineEnum(BuildName(typeInfo.TypeName), TypeAttributes.Class | TypeAttributes.Public, typeof(int)); typeBuildMap[typeInfo] = enumBuilder; for (int i = -EnumRange; i < EnumRange; i++) { if(i<0) { enumBuilder.DefineLiteral("Value_Negative" + Math.Abs(i),i); } else { enumBuilder.DefineLiteral("Value_" + Math.Abs(i), i); } } return enumBuilder.CreateType(); }
private static void GetTypeAttributes(XmlNode xmlNode, ITypeDescription colDesc) { var sourceType = xmlNode.Attributes?["Source"]?.InnerText; if (string.IsNullOrWhiteSpace(sourceType)) { throw new XmlException("Error with attribute 'Name' for 'Type'"); } var destinationType = xmlNode.Attributes?["Destination"]?.InnerText; if (string.IsNullOrWhiteSpace(destinationType)) { throw new XmlException("Error with attribute 'To' for 'Type'"); } colDesc.TypeName = sourceType; colDesc.ConvertTo = destinationType; }
protected override void EmitWriteEnum(ILGenerator gen, ITypeDescription typeDescription, Action loadMember, Action loadMemberAddress) { gen.Emit(OpCodes.Ldarg_0); loadMember(); var storageType = typeDescription.StorageType.Type; if (storageType == typeof(byte)) { gen.Emit(OpCodes.Call, BinarySerializer2WriteByte); } else if (storageType == typeof(sbyte)) { gen.Emit(OpCodes.Call, BinarySerializer2WriteSByte); } else if (storageType == typeof(short)) { gen.Emit(OpCodes.Call, BinarySerializer2WriteInt16); } else if (storageType == typeof(ushort)) { gen.Emit(OpCodes.Call, BinarySerializer2WriteUInt16); } else if (storageType == typeof(int)) { gen.Emit(OpCodes.Call, BinarySerializer2WriteInt32); } else if (storageType == typeof(uint)) { gen.Emit(OpCodes.Call, BinarySerializer2WriteUInt32); } else if (storageType == typeof(long)) { gen.Emit(OpCodes.Call, BinarySerializer2WriteInt64); } else if (storageType == typeof(ulong)) { gen.Emit(OpCodes.Call, BinarySerializer2WriteUInt64); } else { throw new NotImplementedException(); } }
public static XmlMethodsCompiler Create(TypeBuilder typeBuilder, ITypeDescription typeDescription) { var context = new CompilationContext { TypeDescription = typeDescription, SerializerType = typeof(XmlSerializer), ReaderType = typeof(XmlReader), WriterType = typeof(XmlWriter), TypeBuilder = typeBuilder }; return(new XmlMethodsCompiler(typeBuilder, typeDescription, context, new XmlWriteValueMethodCompiler(context), new XmlWriteObjectMethodCompiler(context), new XmlReadValueMethodCompiler(context), new XmlReadObjectMethodCompiler(context))); }
private static Type AddNoNativeType(ITypeDescription typeInfo, IDictionary<ITypeDescription, Type> typeBuildMap, ModuleBuilder modBuilder) { var baseType = typeInfo.BaseClass.Convert(bc=>GetOrCreateType(typeBuildMap, modBuilder,bc )); if(baseType==typeof(Enum)) { return BuildEnum(typeInfo,typeBuildMap, modBuilder); } else { var defineType = CreateType(modBuilder, typeInfo.TypeName, baseType); typeBuildMap[typeInfo] = defineType; foreach (var field in typeInfo.Fields) { CreateFields(defineType, field, modBuilder, typeBuildMap); } return defineType; } }
private static IGeneratedType GenerateType(ModuleBuilder moduleBuilder, ITypeDescription typeDescription, ITypeMapper typeMapper) { var typeBuilder = moduleBuilder.DefineType(typeDescription.Name, TypeAttributes.Public | TypeAttributes.Class); typeBuilder.DefineDefaultConstructor(MethodAttributes.Public); var types = typeDescription.PropertyDescriptions.Select(x => x.Type).ToArray(); var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, types); var index = 1; foreach (var property in typeDescription.PropertyDescriptions) { constructorBuilder.DefineParameter(index, ParameterAttributes.None, property.Name.LowercaseFirst()); index++; } var ctorIl = constructorBuilder.GetILGenerator(); ctorIl.Emit(OpCodes.Ldarg_0); ctorIl.Emit(OpCodes.Call, typeBuilder.BaseType.GetConstructor(Type.EmptyTypes)); index = 1; foreach (var property in typeDescription.PropertyDescriptions) { var targetPropertyType = typeMapper.GetType(property.Type); EmitForPropertyDescription(typeBuilder, property, ctorIl, index, targetPropertyType); index++; } ctorIl.Emit(OpCodes.Ret); var type = typeBuilder.CreateType(); return new GeneratedType(typeDescription.Name, type, typeDescription); }
private static Type CreateType(IDictionary<ITypeDescription, Type> typeBuildMap, ModuleBuilder modBuilder, ITypeDescription typeInfo) { return typeInfo.TryResolveType(t=>GetOrCreateType(typeBuildMap, modBuilder, t)) .Convert(t => AddNativeType(typeInfo, t, typeBuildMap)) .GetValue(() => AddNoNativeType(typeInfo, typeBuildMap, modBuilder)); }
private static Type FindType(ITypeDescription typeInfo, Assembly candidateAssembly) { return typeInfo.TryResolveType(n => FindType(n, candidateAssembly)) .Convert(t => t) .GetValue( () => FindTypeOrArray(typeInfo, candidateAssembly)); }
private static Type FindTypeOrArray(ITypeDescription typeInfo, Assembly candidateAssembly) { return typeInfo.TryResolveType(t =>FindType(t,candidateAssembly)) .GetValue(() => candidateAssembly.GetType(BuildName(typeInfo.TypeName))); }
public GeneratedType(string name, Type type, ITypeDescription typeDescription) { this.Name = name; this.Type = type; this.TypeDescription = typeDescription; }
internal static IEnumerable<SimpleFieldDescription> CreateField(string fieldName, ITypeDescription type) { return new[] { SimpleFieldDescription.Create(fieldName, type) }; }
internal static IEnumerable<SimpleFieldDescription> CreateField(ITypeDescription type) { return CreateField(FieldName, type); }
private static Type AddNativeType(ITypeDescription typeInfo, Type type, IDictionary<ITypeDescription, Type> typeBuildMap) { typeBuildMap[typeInfo] = type; return type; }
private ArrayDescription(TypeName typeName, ITypeDescription innerType) : base(typeName, Maybe.From(KnownType.Array)) { this.innerType = innerType; }
public static ITypeDescription Create(ITypeDescription innerType, int orderOfArray) { var name = TypeName.CreateArrayOf(innerType.TypeName, orderOfArray); return new ArrayDescription(name, innerType); }
internal static IEnumerable<SimpleFieldDescription> CreateArrayField(ITypeDescription type) { var arrayType = ArrayDescription.Create(type, 1); return new[] { SimpleFieldDescription.Create(FieldName, arrayType) }; }
public IGeneratedType GenerateType(ITypeDescription typeDescription) { if (typeDescription == null) { throw new ArgumentNullException("typeDescription"); } return this.GenerateTypes(new[] {typeDescription}).Where(x => x.Name == typeDescription.Name).Single(); }
private static Type GetOrCreateType(IDictionary<ITypeDescription, Type> typeBuildMap, ModuleBuilder modBuilder, ITypeDescription typeInfo) { return typeBuildMap.TryGet(typeInfo) .GetValue(() => CreateType(typeBuildMap, modBuilder, typeInfo)); }
internal static IEnumerable<ITypeDescription> CreateSingleFieldClass(ITypeDescription fieldType) { var type = SimpleClassDescription.Create(SingleFieldType(), f => CreateField(fieldType)); return new[] { type, StringType }; }
private static Type BuildMetaInfoType(ModuleBuilder moduleBuilder, ITypeDescription type) { var typeBuilder = moduleBuilder.DefineType(MetaDataNameSpace + "." + CodeGenerationUtils.ClassName(type.TypeName), CodeGenerationUtils.PublicClass()); AddNameProperty(typeBuilder, type); return typeBuilder.CreateType(); }
private bool Equals(ITypeDescription other) { if (ReferenceEquals(null, other)) return false; if (ReferenceEquals(this, other)) return true; return Equals(other.TypeName, TypeName); }
private TypeBuilder FindLocationForProperty(ByNameGrouping type, ITypeDescription forType) { if (type.HasMultipleValues) { var typeNameSeparation = forType.TypeName.NameAndNamespace.LastIndexOf('.'); var namespaceName = forType.TypeName.NameAndNamespace.Substring(0, typeNameSeparation); return GetOrCreateNamespaceFor(namespaceName); } return rootType; }
public static SimpleFieldDescription Create(string fieldName, ITypeDescription type, IndexingState indexState = IndexingState.Unknown) { return new SimpleFieldDescription(fieldName, type, indexState); }
public void RegisterNewType(ITypeDescription source, IGeneratedType generatedType) { typeDescritpions[source] = generatedType; }
private string NameOfProperty(ITypeDescription typeDescription) { var name = typeDescription.TypeName.NameWithGenerics.Split('.').Last().Replace('+', '_'); if(needsAssemblyInName.Contains(typeDescription)) { return name + "_" + CodeGenerationUtils.NormalizedAssemblyName(typeDescription.TypeName); } return name; }