Example #1
0
        public void Add(RuntimicSystemModel model, UnifiedTypeNode node)
        {
            //if (!model.Unified.Types.Sets.TryGetValue(node.ResolutionName, out UnifiedTypeNodeSet set))
            //{
            //	set = new UnifiedTypeNodeSet()
            //	{
            //		ResolutionName = node.ResolutionName
            //	};

            //	model.Unified.Types.Sets.Add(node.ResolutionName, set);
            //}

            //if (set.First == null)
            //{
            //	set.First = node;
            //	set.Last = node;
            //}
            //else
            //{
            //	set.Last.Next = node;
            //	set.Last = node;
            //}

            throw new System.NotImplementedException();
        }
Example #2
0
        public TypeReference EnsureReference(InfrastructureRuntimicModelMask_I model, Type type, out UnifiedTypeNode unifiedNode)
        {
            throw new System.Exception("Fix");

            //var metadataToken = type.MetadataToken;

            //// Ensure bound entry

            //// Ensure Cecil entry

            //// If a type is converted, then a seperate converted entry is created in a corresponding module. Types from different assemlibes cannot be combined
            //// without most likely making IL changes to support the additional types.

            //string resolutionName = Types.Naming.GetResolutionName(type);

            ////if (resolutionName == "Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.ComplicatedGenericWithOneArgBaseConstructorCall`3, E01D.Pal.Apps.Common, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null")
            ////{

            ////}

            //TypeReference result = Types.Getting.GetStoredTypeReference(model, resolutionName, out unifiedNode);

            //if (result != null) return result;

            //if (type.IsGenericType && !type.IsGenericTypeDefinition)
            //{
            //	var genericArguments = type.GenericTypeArguments;

            //	var genericTypeDefinition = type.GetGenericTypeDefinition();

            //	var genericTypeDefinition1 = EnsureReference(model, genericTypeDefinition);

            //	var genericArgumentReferences = new TypeReference[genericArguments.Length];

            //	for (int i = 0; i < genericArguments.Length; i++)
            //	{
            //		genericArgumentReferences[i] = EnsureReference(model, genericArguments[i]);
            //	}

            //	result = genericTypeDefinition1.MakeGenericInstanceType(genericArgumentReferences);

            //	var assemblyNode = Assemblies.Ensuring.Ensure(model, type.Assembly);

            //	var moduleNode = Unified.Modules.Get(model, type.Module.Name);

            //	Unified.Types.Extend(model, assemblyNode, moduleNode, result);
            //}
            //else
            //{
            //	// This should load the assembly, module and types into the model.
            //	Assemblies.Ensuring.Ensure(model, type.Assembly);

            //	result = Types.Getting.GetStoredTypeReference(model, resolutionName, out unifiedNode);

            //	if (result == null)
            //	{
            //		throw new Exception($"Type definition for {type.AssemblyQualifiedName} is not loaded.");
            //	}
            //}

            //return result;
        }
Example #3
0
        public TypeReference EnsureReference(InfrastructureRuntimicModelMask_I model, TypeReference inputReference, out UnifiedTypeNode unifiedNode)
        {
            //string resolutionName = Types.Naming.GetResolutionName(inputReference);

            //var result = Types.Getting.GetStoredTypeReference(model, resolutionName, out unifiedNode);

            //if (result != null) return result;

            //if (inputReference.IsGenericInstance)
            //{
            //	GenericInstanceType genericInstance = (GenericInstanceType) inputReference;

            //	var genericArguments = genericInstance.GenericArguments;

            //	var genericTypeDefinition = genericInstance.ElementType;

            //	var genericTypeDefinition1 = EnsureReference(model, genericTypeDefinition, out UnifiedTypeNode genericUnifiedNode);

            //	var genericArgumentReferences = new TypeReference[genericArguments.Count];

            //	for (int i = 0; i < genericArguments.Count; i++)
            //	{
            //		genericArgumentReferences[i] = EnsureReference(model, genericArguments[i]);
            //	}

            //	result = genericTypeDefinition1.MakeGenericInstanceType(genericArgumentReferences);

            //	var assemblyNode = Assemblies.Ensuring.Ensure(model, inputReference.Scope);

            //	//var moduleNode = Unified.Modules.Get(model, type.Module.Name);

            //	throw new Exception("Debug");

            //	//Unified.Types.Extend(model, assemblyNode, moduleNode, result);
            //}
            //else
            //{
            //	// This should load the assembly, module and types into the model.
            //	Assemblies.Ensuring.Ensure(model, inputReference.Scope);

            //	result = Types.Getting.GetStoredTypeReference(model, resolutionName, out unifiedNode);

            //	if (result == null)
            //	{
            //		throw new Exception($"Type definition for {resolutionName} is not loaded.");
            //	}
            //}

            //return result;

            throw new Exception("");
        }