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