public void CanGenerateCodeForVariantMapping() { var tg = new TypeGenerator(); var mapping = JsonConvert.DeserializeObject <Mapping>(File.ReadAllText(TestFiles.AToXVariantMapping)); var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "Source"); var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "Target"); Write(source.Code); Write(target.Code); mapping.RebuildRelationships(); var mappings = new Dictionary <int, TypeMapping>(); var sourceItem = mapping.SourceInfo.Roots[0]; var targetItem = mapping.TargetInfo.Roots[0]; var resolver = new TypeResolver(); resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping); var generator = new Generator(); var sb = new StringBuilder(); var writer = new StringWriter(sb); generator.Generate(writer, mappings, source.RootType, target.RootType, mapping.TargetInfo.Roots[0], mapping); var result = sb.ToString(); Write(result); Assert.True(result.Contains("target.Z = MapNoTitleToZ(Source?.B);"), "Array was correctly passed as a parameter"); Assert.True(result.Contains("public virtual Target.Z MapNoTitleToZ(IEnumerable<Source.Anonymous> B)"), "array was correctly added as method argument"); }
private static int GenerateMappint(Mapping mapping, Options opt) { var tg = new TypeGenerator(); var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "SourceNs"); var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "TargetNs"); mapping.RebuildRelationships(); var mappings = new Dictionary <int, TypeMapping>(); var sourceItem = mapping.SourceInfo.Roots[0]; var targetItem = mapping.TargetInfo.Roots[0]; var resolver = new TypeResolver(); resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping); var generator = new Generator(); var sb = new StringBuilder(); var writer = new StringWriter(sb); generator.Generate(writer, mappings, source.RootType, target.RootType, mapping.TargetInfo.Roots[0], mapping); var entrypointGen = new EntryPointGenerator(); var azureWriter = new OutputWriter(); var codeGen = new List <CodeGenerationResult>() { source, target }; azureWriter.WriteOutput(opt.OutputDirectory, sb.ToString(), entrypointGen.Generate(source.RootType, target.RootType, codeGen), codeGen); return(0); }
public void CanGenerateCodeForNestedMapping() { var tg = new TypeGenerator(); var mapping = JsonConvert.DeserializeObject <Mapping>(File.ReadAllText(TestFiles.AToXMapping)); var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "Mapping"); var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "Mapping"); Write(source.Code); Write(target.Code); mapping.RebuildRelationships(); var mappings = new Dictionary <int, TypeMapping>(); var sourceItem = mapping.SourceInfo.Roots[0]; var targetItem = mapping.TargetInfo.Roots[0]; var resolver = new TypeResolver(); resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping); var generator = new Generator(); var sb = new StringBuilder(); var writer = new StringWriter(sb); generator.Generate(writer, mappings, source.RootType, target.RootType, mapping.TargetInfo.Roots[0], mapping); Write(sb.ToString()); }
public static bool CreateDefault(Type type, out object defaultValue) { try { defaultValue = Activator.CreateInstance(type); return(true); } catch (Exception) { foreach (var creator in _defaultInstanceCreators) { if (creator.HandlesType(type)) { defaultValue = creator.CreateDefault(type); return(true); } } } var typeName = TypeGenerator.Generate(type); if (EditorUtility.DisplayDialog( "No IDefaultInstanceCreator found", "There's no IDefaultInstanceCreator implementation to handle the type '" + typeName + "'.\n" + "Providing an IDefaultInstanceCreator enables you to create instances for that type.\n\n" + "Do you want to generate an IDefaultInstanceCreator implementation for '" + typeName + "'?\n", "Generate", "Cancel" )) { generateIDefaultInstanceCreator(typeName); } defaultValue = null; return(false); }
static void Main(string[] args) { var xmlCache = new VkXmlCache(".\\VkTemplates"); var jsonCache = new SpirvJsonCache(".\\VkTemplates"); var parser = new SpecParser(xmlCache, ".\\VkTemplates"); var generator = new TypeGenerator(); var types = generator.Generate(parser.Run()); var fileGenerator = new FileGenerator("..\\..\\..\\SharpVk"); foreach (var modelGenerator in new ModelGenerator <TypeSet>[] { new VkCommandsGenerator(), new VkHandleGenerator(), new VkDelegateGenerator(), new VkEnumGenerator(), new VkStructsGenerator(), new VkUnionsGenerator(), new VkExceptionGenerator(), new VkConstantGenerator(), new VkInteropStructsGenerator() }) { modelGenerator.Run(types, fileGenerator); } new SpirvEnumGenerator().Run(jsonCache.GetSpirvModel(), fileGenerator); var grammarModel = jsonCache.GetSpirvGrammar(); new SpirvOpCodeGenerator().Run(grammarModel, fileGenerator); new SpirvOperandKindGenerator().Run(grammarModel, fileGenerator); }
private static void _AssignObjectProperties(out object?obj, Type type, DeserializationContext context) { obj = type.GetTypeInfo().IsInterface ? TypeGenerator.Generate(type) : context.RootSerializer.Options.Resolver.Resolve(type, context.ValueMap); _AssignObjectProperties(ref obj, context.ValueMap); }
private void GenerateType(SourceGeneratorContext context, INamedTypeSymbol type) { var structure = new JsonType(type); var code = TypeGenerator.Generate(structure); context.AddSource($"{type.Name}.Generated.cs", SourceText.From(code, Encoding.UTF8)); }
private object _ResolveSlow(Type type, JsonValue json, IResolver resolver) { if (json != null && json.Type == JsonValueType.Object && json.Object.ContainsKey(Constants.TypeKey)) { var concrete = Type.GetType(json.Object[Constants.TypeKey].String); return(resolver.Resolve(concrete)); } if (!_registry.TryGetValue(type, out Type tConcrete)) { Type typeToLookup = type; if (type.GetTypeInfo().IsGenericType) { typeToLookup = type.GetGenericTypeDefinition(); } _registry.TryGetValue(typeToLookup, out tConcrete); } if (tConcrete != null) { if (tConcrete.GetTypeInfo().IsGenericTypeDefinition) { tConcrete = tConcrete.MakeGenericType(type.GetTypeArguments()); } return(resolver.Resolve(tConcrete)); } if (type.GetTypeInfo().IsInterface) { return(TypeGenerator.Generate(type)); } return(resolver.Resolve(type)); }
public void SingleAttributeTypeDataTest() { var generator = new TypeGenerator(); var type = typeof(System.IComparable); var result = generator.Generate(type); Assert.AreEqual("System.IComparable", result); }
public Type Build(ProxyDefinition proxyDefinition) { var typeMetadata = ProxyMetadataFactory.BuildTypeMetadata(proxyDefinition); var generator = new TypeGenerator(_moduleBuilder, _proxyNamespace, typeMetadata); return generator.Generate(); }
public void CreateObject() { TypeDefine def = new TypeDefine("DynamicTypeTest", "SampleObject"); TypeGenerator g = new TypeGenerator(def); Type t = g.Generate(); Assert.AreEqual("SampleObject", t.Name); }
public void MethodCall_Success() { var instance = TypeGenerator.Generate <IInterface>(); var actual = instance.RequiredMethod <int, IConvertible>(2.0); Assert.AreEqual(default(int), actual); }
public void EventSubscription_Success() { var instance = TypeGenerator.Generate <IInterface>(); EventHandler handler = (o, e) => { }; instance.RequiredEvent += handler; instance.RequiredEvent -= handler; }
public void CacheTypes_Success() { var instance = TypeGenerator.Generate <IInterface>(); var instance2 = TypeGenerator.Generate <IInterface>(); Assert.AreNotSame(instance, instance2); Assert.AreEqual(instance.GetType(), instance2.GetType()); Console.WriteLine("Caching succeeded."); }
public void CanGenerateCodeForNestedMapping() { var tg = new TypeGenerator(); var mapping = JsonConvert.DeserializeObject <Mapping>(File.ReadAllText(TestBase.TestFiles.AToXMapping)); var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "SourceNs"); var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "TargetNs"); output.WriteLine(source.Code); mapping.RebuildRelationships(); var mappings = new Dictionary <int, TypeMapping>(); var sourceItem = mapping.SourceInfo.Roots[0]; var targetItem = mapping.TargetInfo.Roots[0]; var resolver = new TypeResolver(); resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping); var generator = new Generator(); var sb = new StringBuilder(); var writer = new StringWriter(sb); generator.Generate(writer, mappings, source.RootType, target.RootType, mapping.TargetInfo.Roots[0], mapping); var entrypointGen = new EntryPointGenerator(); var azureWriter = new OutputWriter(); var codeGen = new List <CodeGenerationResult>() { source, target }; var basePath = @"I:\AzureFunctions\src\azure-webjobs-sdk-script\sample\HttpTrigger-MappingDemo"; // @"F:\temp\azure"; azureWriter.WriteOutput(basePath, sb.ToString(), entrypointGen.Generate(source.RootType, target.RootType, codeGen), codeGen); Assert.True(File.Exists(Path.Combine(basePath, "bin\\Source.dll"))); Assert.True(File.Exists(Path.Combine(basePath, "bin\\Target.dll"))); Assert.True(File.Exists(Path.Combine(basePath, "function.json"))); Assert.True(File.Exists(Path.Combine(basePath, "run.csx"))); }
public void PropertyReadAndWrite_Success() { string stringProp = "test"; var instance = TypeGenerator.Generate <IInterface>(); instance.RequiredProp = stringProp; Assert.AreEqual(stringProp, instance.RequiredProp); }
public void PropertyReadAndWrite_Success() { var stringProp = "test"; var instance = (IInterface)TypeGenerator.Generate(typeof(IInterface)); instance.RequiredProp = stringProp; Assert.AreEqual(stringProp, instance.RequiredProp); }
private object _ResolveSlow(Type type, JsonValue?json, IResolver resolver, Dictionary <SerializationInfo, object?>?parameters) { var typeToResolve = IdentifyTypeToResolve(type, json); if (typeToResolve.GetTypeInfo().IsInterface) { return(TypeGenerator.Generate(type)); } return(resolver.Resolve(typeToResolve, parameters)); }
private bool AdjustStringMembers(TypeGenerator generator, FileAnalyzer analyzer) { analyzer.Stream.Position = 0; var enumerableType = typeof(StorageEnumerable <>).MakeGenericType(analyzer.RecordType); var enumerable = (IEnumerable)Activator.CreateInstance(enumerableType, analyzer.Stream, analyzer.Options); var isValidString = new bool[analyzer.Members.Members.Count]; for (var itr = 0; itr < isValidString.Length; ++itr) { isValidString[itr] = false; } foreach (var node in enumerable) { var memberIndex = 0; foreach (var exMemberInfo in analyzer.Members.Members) { if (memberIndex == analyzer.Members.IndexColumn) { ++memberIndex; continue; } var memberInfo = (PropertyInfo)exMemberInfo.MemberInfo; var memberValue = memberInfo.GetValue(node); if (exMemberInfo.Type == typeof(string)) { isValidString[memberIndex] = exMemberInfo.MappedTo.BitSize > 16 && memberValue != null; } ++memberIndex; } } for (var itr = 0; itr < isValidString.Length; ++itr) { if (!isValidString[itr]) { generator.GetMember(itr).Type = typeof(int); } } if (isValidString.Any()) { generator.Generate(); } return(isValidString.Any()); }
public void CanGenerateCodeForJsonToXsdMapping() { // This test has some issues - specifically the class generated from the JSON schema is weird. Until that is resolved it won't pass. var tg = new TypeGenerator(); var mapping = JsonConvert.DeserializeObject <Mapping>(File.ReadAllText(TestFiles.JsonToXsd)); var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "Source"); var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "Target"); Write(source.Code); Write(target.Code); Assert.NotNull(source.Assembly); Assert.NotNull(target.Assembly); Assert.NotNull(source.RootType); Assert.NotNull(target.RootType); mapping.RebuildRelationships(); var mappings = new Dictionary <int, TypeMapping>(); var sourceItem = mapping.SourceInfo.Roots[0]; var targetItem = mapping.TargetInfo.Roots[0]; var resolver = new TypeResolver(); resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping); var generator = new Generator(); var sb = new StringBuilder(); generator.Generate(new StringWriter(sb), mappings, source.RootType, target.RootType, mapping.TargetInfo.Roots[0], mapping); var result = sb.ToString(); Write(result); }
public void CanResolveTypesForSourceAndTargetAToX() { var tg = new TypeGenerator(); var mapping = JsonConvert.DeserializeObject <Mapping>(File.ReadAllText(TestFiles.AToXMapping)); var source = tg.Generate(mapping.SourceInfo.PhysicalSchema, "Mapping"); var target = tg.Generate(mapping.TargetInfo.PhysicalSchema, "Mapping"); Write(source.Code); Write(target.Code); mapping.RebuildRelationships(); var mappings = new Dictionary <int, TypeMapping>(); var sourceItem = mapping.SourceInfo.Roots[0]; var targetItem = mapping.TargetInfo.Roots[0]; var resolver = new TypeResolver(); resolver.Resolve(mappings, source.RootType, target.RootType, sourceItem, targetItem, mapping); Assert.Equal(7, mappings.Keys.Count); var wTargetItemId = 33309; var wTypeMapping = mappings[wTargetItemId]; Assert.Equal(1, wTypeMapping.Mappings.Count); Assert.NotNull(wTypeMapping.Mappings[0].SourcePath); foreach (var tm in mappings.Values) { foreach (var schemaItemMapping in tm.Mappings) { Write(string.Format("Item {0} of type {1} will be mapped from {2}", schemaItemMapping.TargetSchemaItem.title, tm.TargetProperty, schemaItemMapping.SourceProperty)); Assert.NotNull(schemaItemMapping.SourcePath); } } }
static void Main(string[] args) { if (args.Count() > 0) { TypeGenerator.Generate(Type.GetType(args [0])); return; } Predicate <string> test = (s) => { Console.WriteLine(s); return(true); }; IntPtr ptr = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(test); var method = typeof(System.Runtime.InteropServices.Marshal).GetMethod("GetDelegateForFunctionPointerInternal", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static); try { var obj = method.Invoke(null, new object[] { ptr, typeof(Action) }); Predicate <string> test2 = (Predicate <string>)obj; bool result = test2("TEST"); if (result) { Console.WriteLine("TEST2"); } } catch (Exception e) { Console.WriteLine(e.Message); } //TypeGenerator.Generate (typeof(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationTokenTable<>)); /* * TypeGenerator.Generate (typeof(Type)); * TypeGenerator.Generate (typeof(System.Reflection.MemberInfo)); * TypeGenerator.Generate (typeof(System.Reflection.Module)); * TypeGenerator.Generate (typeof(System.Reflection.ICustomAttributeProvider)); * TypeGenerator.Generate (typeof(System.Runtime.InteropServices._MemberInfo)); * TypeGenerator.Generate (typeof(System.Runtime.InteropServices._Module)); * TypeGenerator.Generate (typeof(System.Runtime.Serialization.ISerializable)); */ //AssemblyParser.Parse(typeof(string).Assembly); //Console.ReadLine(); }
private void GenerateObjectsOfDifferentTypes() { const int typeMaxCount = 100; var generatedTypes = TypeGenerator.Generate(typeMaxCount); var coeff = Count / typeMaxCount; for (int i = 0; i < Count; i++) { var go = SpawnObject(i, Distance / 2); var typeIndex = i / coeff; var component = go.AddComponent(generatedTypes[typeIndex]); _spawnedObjects.Add(go); //var methodInfo = generatedTypes[typeIndex].GetMethod("Update", BindingFlags.Instance | BindingFlags.NonPublic); //UpdateManager.Instance.Updated += () => methodInfo.Invoke(component, null); } }
static void drawUnsupportedType(Type type, string fieldName, object value) { EditorGUILayout.BeginHorizontal(); EditorGUILayout.LabelField(fieldName, value.ToString()); if (GUILayout.Button("Missing ITypeDrawer", GUILayout.Height(14))) { var typeName = TypeGenerator.Generate(type); if (EditorUtility.DisplayDialog( "No ITypeDrawer found", "There's no ITypeDrawer implementation to handle the type '" + typeName + "'.\n" + "Providing an ITypeDrawer enables you draw instances for that type.\n\n" + "Do you want to generate an ITypeDrawer implementation for '" + typeName + "'?\n", "Generate", "Cancel" )) { generateITypeDrawer(typeName); } } EditorGUILayout.EndHorizontal(); }
public static void Parse(Assembly assembly) { var sb = new StringBuilder(); var types = assembly.GetTypes().Where(x => x.IsPublic); foreach (var type in types) { if (type == typeof(System.Collections.Concurrent.OrderablePartitioner <>)) { continue; } if (type.Name.StartsWith("Tuple")) { continue; } if (!type.IsBaseType()) { TypeGenerator.Generate(type); sb.AppendLine("#include <" + type.GetTypePath() + ".h>"); } } System.IO.File.WriteAllText(System.IO.Path.Combine(FileGenerator.GetRootPath(), assembly.GetName().Name + ".h"), sb.ToString()); }
public void NullDataTest() { var generator = new TypeGenerator(); Assert.Throws(typeof(ArgumentNullException), () => generator.Generate(null)); }
public string LiteralDataTest(string data) { var generator = new TypeGenerator(); return(generator.Generate(data)); }
public void TypeCreation_Success() { var instance = TypeGenerator.Generate <IInterface>(); Assert.IsNotNull(instance); }
string generate <T>() { return(TypeGenerator.Generate(typeof(T))); }
public void ThrowExceptionForAbstractTypeGeneration() { var abstractGenerator = new TypeGenerator <Animal>(); Assert.Throws <MissingMethodException>(() => abstractGenerator.Generate()); }
public void InvalidDataTypeTest() { var generator = new TypeGenerator(); Assert.Throws(typeof(InvalidOperationException), () => generator.Generate(123)); }