public void BuildOut(RuntimicSystemModel semanticModel, SemanticAssemblyMask_I semanticAssembly)
{
if (semanticAssembly.IsBuiltOut)
{
return;
}
if (!semanticAssembly.IsBound())
{
throw new System.NotImplementedException("Semantic assemblies not handled");
}
BoundAssembly_I boundAssembly = (BoundAssembly_I)semanticAssembly;
var list = Modules.Ensuring.EnsureAll(semanticModel, boundAssembly);
for (int i = 0; i < list.Count; i++)
{
var moduleEntry = list[i];
Modules.Building.BuildOut(semanticModel, moduleEntry);
}
boundAssembly.IsBuiltOut = true;
}
public bool TryGet(RuntimicSystemModel model, string resolutionName, out SemanticAssemblyMask_I semanticAssemblyMask)
{
var node = Unified.Assemblies.Get(model, resolutionName);
semanticAssemblyMask = node?.Semantic;
return(node != null);
}
public SemanticModuleMask_I GetModuleEntry(SemanticAssemblyMask_I assemblyEntry, ModuleDefinition moduleDefinition)
{
// If corelib, set to false.
// check exclusion list, set to false.
if (!assemblyEntry.Modules.TryGetValue(moduleDefinition.Name, out SemanticModuleMask_I moduleEntry))
{
throw new Exception("Module not found");
}
return(moduleEntry);
}
public void AddAssemblyEntry(ILConversion conversion, SemanticAssemblyMask_I entry)
{
var semanticModel = conversion.Model;
if (entry.IsConverted() && entry is ConvertedAssembly_I convertedAssembly)
{
semanticModel.Semantic.Assemblies.Collectible.Add(entry.ResolutionName(), convertedAssembly);
//conversion.Result.Assemblies.Add(convertedAssembly.AssemblyBuilder);
}
Bound.Metadata.Assemblies.Addition.AddAssemblyEntry(conversion.Model, entry);
}
public SemanticModuleMask_I GetModule(ILConversion conversion, SemanticAssemblyMask_I modulesAssembly, TypeReference typeReference)
{
if (modulesAssembly.Modules.Count == 0)
{
throw new Exception("Expected assembly to have at least one module");
}
if (modulesAssembly.Modules.Count == 1)
{
return(modulesAssembly.Modules.Values.FirstOrDefault());
}
throw new Exception("More than one module not supported at this time.");
}
public void AddAssemblyReferences(ILConversion conversion, SemanticAssemblyMask_I assemblyEntry)
{
var semanticModel = conversion.Model;
//foreach (var moduleDefinition in assemblyEntry.AssemblyDefinition.Modules)
//{
// foreach (var assemblyNameReference in moduleDefinition.AssemblyReferences)
// {
// var fullAssemblyName = assemblyNameReference.FullName;
// SemanticAssemblyMask_I referencedEntry = null;
// if (semanticModel.Semantic.Assemblies.ByResolutionName.TryGetValue(fullAssemblyName, out SemanticAssemblyMask_I referenceAssemblyEntry))
// {
// referencedEntry = referenceAssemblyEntry;
// }
// else
// {
// var loadedAssembly = this.Metadata.Assemblies.FindAssemblyInAppDomain(fullAssemblyName);
// if (loadedAssembly != null && !loadedAssembly.IsDynamic)
// {
// //referencedEntry = Conversion.Metadata.Assemblies.Creation.CreateAssemblyEntry(conversion, loadedAssembly);
// AddAssemblyReferences(conversion, referencedEntry);
// }
// else
// {
// throw new Exception("Assembly not resolved. Need to add secondary resolving logic.");
// }
// }
// //assemblyEntry.Assemblies.Referenced.Add(referencedEntry.ResolutionName(), referencedEntry);
// //referencedEntry.Assemblies.Referencing.Add(assemblyEntry.ResolutionName(), assemblyEntry);
// }
//}
}
public void AddAssemblyEntry(InfrastructureRuntimicModelMask_I semanticModel, SemanticAssemblyMask_I entry)
{
throw new System.Exception("Not supported currently.");
//semanticModel.Semantic.Assemblies.ByResolutionName.Add(entry.ResolutionName(), entry);
//Infrastructure.Models.Structural.AddAssemblyDefinition(semanticModel, entry.AssemblyDefinition);
}
public List <SemanticModuleMask_I> EnsureAll(RuntimicSystemModel semanticModel, SemanticAssemblyMask_I semanticAssembly)
{
throw new System.NotImplementedException();
}
public bool TryGet(RuntimicSystemModel semanticModel, string resolutionName, out SemanticAssemblyMask_I semanticAssemblyMask)
{
return(Semantic.Metadata.Assemblies.TryGet(semanticModel, resolutionName, out semanticAssemblyMask));
}
public List <SemanticModuleMask_I> EnsureAll(RuntimicSystemModel semanticModel, SemanticAssemblyMask_I semanticAssembly)
{
// Ensure the module definition is in the assemlby definition that is past, and has not been loaded twice.
if (!semanticAssembly.IsSemantic() && !semanticAssembly.IsBound())
{
throw new System.Exception("The assembly should be semantic or bound.");
}
if (semanticAssembly.IsSemantic())
{
return(Semantic.Metadata.Modules.Ensuring.EnsureAll(semanticModel, semanticAssembly));
}
var boundAssembly = (BoundAssembly_I)semanticAssembly;
var modules = new List <SemanticModuleMask_I>();
foreach (var moduleDefinition in boundAssembly.AssemblyDefinition.Modules)
{
var module = Ensure(semanticModel, boundAssembly, moduleDefinition);
modules.Add(module);
}
return(modules);
}
