public ICliMetadataTypeDefinitionTableRow FindType(IGeneralTypeUniqueIdentifier uniqueIdentifier) { if (uniqueIdentifier.ParentIdentifier != null) { var cliType = IdentityManager.ObtainTypeReference(this.FindType(uniqueIdentifier.ParentIdentifier)); if (cliType is ICliTypeParent) { var clipt = (ICliTypeParent)cliType; return(clipt.FindType(uniqueIdentifier)); } } if (uniqueIdentifier.Name.Contains('`')) { return(this.FindType(uniqueIdentifier.Namespace.Name, uniqueIdentifier.Name)); } else if (uniqueIdentifier is IGenericTypeUniqueIdentifier) { var genericUniqueId = uniqueIdentifier as IGenericTypeUniqueIdentifier; if (genericUniqueId.TypeParameters > 0) { return(this.FindType(uniqueIdentifier.Namespace.Name, string.Format("{0}`{1}", uniqueIdentifier.Name, ((IGenericTypeUniqueIdentifier)(uniqueIdentifier)).TypeParameters))); } } if (uniqueIdentifier.Namespace == null) { return(this.FindType(null, uniqueIdentifier.Name)); } else { return(this.FindType(uniqueIdentifier.Namespace.Name, uniqueIdentifier.Name)); } }
public override IType GetType(IGeneralTypeUniqueIdentifier identifier) { var typeDefinition = GetTypeDefinition(identifier); if (typeDefinition != null) { return(this.IdentityManager.ObtainTypeReference(typeDefinition)); } return(null); }
private ICliMetadataTypeDefinitionTableRow GetTypeDefinition(IGeneralTypeUniqueIdentifier identifier) { var nestingHierarchy = identifier.GetNestingHierarchy(); ICliMetadataTypeDefinitionTableRow typeDefinition = null; bool first = true; while (nestingHierarchy.Count > 0) { var current = nestingHierarchy.Pop(); if (first) { /* * * Going off of a true namespace setup. * */ var topLevelType = this.FindType(current); if (topLevelType == null) { return(null); } typeDefinition = topLevelType; first = false; } else { bool found = false; string name = current.Name; if (current is IGenericTypeUniqueIdentifier) { var genericCurrent = ((IGenericTypeUniqueIdentifier)current); if (!genericCurrent.UsesNonstandardGraveAccentElement) { name = string.Format("{0}`{1}", name, genericCurrent.TypeParameters); } } foreach (var nestedType in typeDefinition.NestedClasses) { if (nestedType.Name == name && current.Namespace == null && string.IsNullOrEmpty(nestedType.Namespace) || (current.Namespace != null && nestedType.Namespace == current.Namespace.Name)) { typeDefinition = nestedType; found = true; break; } } if (!found) { return(null); } } } return(typeDefinition); }
public static Stack <IGeneralTypeUniqueIdentifier> GetNestingHierarchy(this IGeneralTypeUniqueIdentifier identifier) { var nestingHierarchy = new Stack <IGeneralTypeUniqueIdentifier>(); var id = (IGeneralTypeUniqueIdentifier)identifier; while (id != null) { nestingHierarchy.Push(id); id = id.ParentIdentifier; } return(nestingHierarchy); }
private string ReadBoilerplateAttribute(IGeneralTypeUniqueIdentifier attributeTypeIdentifier) { var attributeType = owner.IdentityManager.ObtainTypeReference(attributeTypeIdentifier, this.owner); if (owner.IsDefined(attributeType)) { var attributeDef = owner.Metadata[attributeType]; var firstCtorVal = attributeDef.Parameters.FirstOrDefault(); var stringTypeRef = owner.IdentityManager.ObtainTypeReference(RuntimeCoreType.String, owner); if (firstCtorVal.ParameterType == stringTypeRef) { return(firstCtorVal.Value as string); } } return(null); }
public IType ObtainTypeReference(IGeneralTypeUniqueIdentifier typeIdentity, IAssembly originatingAssembly) { /* * * With no assembly as a guide, a guess has to be made. * */ if (typeIdentity.Assembly == null) { if (this.RuntimeEnvironment.UseCoreLibrary) { var coreLibraryId = this.RuntimeEnvironment.CoreLibraryIdentifier; var coreLibrary = this.ObtainAssemblyReference(coreLibraryId); var cliCoreLibrary = (ICliAssembly)coreLibrary; var type = cliCoreLibrary.GetType(typeIdentity); if (type != null) { return(type); } } if (originatingAssembly != null) { var originatingSearch = originatingAssembly.GetType(typeIdentity); if (originatingSearch != null) { return(originatingSearch); } foreach (var assembly in originatingAssembly.References.Values) { var test = assembly.GetType(typeIdentity); if (test != null) { return(test); } } } } else { var assembly = this.ObtainAssemblyReference(typeIdentity.Assembly); var type = assembly.GetType(typeIdentity); if (type != null) { return(type); } } throw new TypeLoadException(string.Format("Could not load {0}.", typeIdentity.ToString())); }
public ICliMetadataTypeDefinitionTableRow FindType(IGeneralTypeUniqueIdentifier uniqueIdentifier) { var myID = this.UniqueIdentifier; var depth = ((IGeneralTypeUniqueIdentifier)this.UniqueIdentifier).GetDepth(); /* * * If the hierarchy of the unique identifier is properly formed, then * the current type's identifier should be contained within it. * */ var hierarchy = uniqueIdentifier.GetNestingHierarchy().Skip(depth - 1); var first = hierarchy.FirstOrDefault(); if (first == null || !myID.Equals(first)) { return(null); } ICliMetadataTypeDefinitionTableRow typeDefinition = this.MetadataEntry; var remainingHierarchy = new Stack <IGeneralTypeUniqueIdentifier>(hierarchy.Skip(1).Reverse()); while (remainingHierarchy.Count > 0) { var current = remainingHierarchy.Pop(); bool found = false; foreach (var nestedType in typeDefinition.NestedClasses) { if (nestedType.Name == current.Name && current.Namespace == null && string.IsNullOrEmpty(nestedType.Namespace) || (current.Namespace != null && nestedType.Namespace == current.Namespace.Name)) { typeDefinition = nestedType; found = true; break; } } if (!found) { return(null); } } return(typeDefinition); }
public IType ObtainTypeReference(IGeneralTypeUniqueIdentifier typeIdentity) { return(ObtainTypeReference(typeIdentity, null)); /* * * With no assembly as a guide, a guess has to be made. * */ if (typeIdentity.Assembly == null) { if (this.RuntimeEnvironment.UseCoreLibrary) { var coreLibraryId = this.RuntimeEnvironment.CoreLibraryIdentifier; var coreLibrary = this.ObtainAssemblyReference(coreLibraryId); var type = coreLibrary.GetType(typeIdentity); if (type != null) { return(type); } foreach (var assembly in this.loadedAssemblies.Values) { if (assembly.UniqueIdentifier == coreLibraryId) { continue; } else if ((type = assembly.GetType(typeIdentity)) != null) { return(type); } } } } else { var assembly = this.ObtainAssemblyReference(typeIdentity.Assembly); var type = assembly.GetType(typeIdentity); if (type != null) { return(type); } } throw new TypeLoadException(string.Format("Could not load {0}.", typeIdentity.ToString())); }
public ICliMetadataTypeDefinitionTableRow FindType(IGeneralTypeUniqueIdentifier uniqueIdentifier) { return(CliCommon.FindTypeImplementation(this.IdentityManager, this.Assembly, uniqueIdentifier, this.namespaceInfo)); }
public ICliMetadataTypeDefinitionTableRow FindType(IGeneralTypeUniqueIdentifier uniqueIdentifier) { throw new NotImplementedException(); }
/// <summary> /// Returns the <see cref="IType"/> for the <paramref name="identifier"/> /// provided. /// </summary> /// <param name="identifier">The <see cref="IGeneralTypeUniqueIdentifier"/> to obtain the /// <see cref="IType"/> of.</param> /// <returns>A <see cref="IType"/> from the current <see cref="AssemblyBase"/> /// which is represented by the <paramref name="identifier"/>.</returns> public abstract IType GetType(IGeneralTypeUniqueIdentifier identifier);