/// <summary> /// Creates if necessary the base type and update the base type list of the specified type /// </summary> /// <param name="baseTypeName">Base type name to create and add</param> /// <param name="type">The type whose base type list needs updating</param> /// <param name="isExistingType">Whether the type is a new type or existent one</param> private void AddBaseTypeOfType(string baseTypeName, ContentTypeImpl type, bool isExistingType) { if (baseTypeName != null) { string uppercaseBaseTypeName = baseTypeName.ToUpperInvariant(); // no content type can derive from unknown // Do this check before GetOrCreateContentType because it provides a more meaningful exception message if (baseTypeName == ContentTypeRegistryImpl.UnknownContentTypeName) { throw new InvalidOperationException(String.Format(System.Globalization.CultureInfo.CurrentUICulture, Strings.ContentTypeRegistry_ContentTypesCannotDeriveFromUnknown, type.TypeName)); } // Get existing or create new base content type if any base type is specified ContentTypeImpl baseType; bool isExistingBaseType = GetOrCreateContentType(baseTypeName, out baseType); // Only a new mapping between two existing nodes can introduce a cycle in the graph. if (isExistingType && isExistingBaseType && this.CausesCycle(type, baseType)) { throw new InvalidOperationException(String.Format(System.Globalization.CultureInfo.CurrentUICulture, Strings.ContentTypeRegistry_CausesCycles, baseType.TypeName, type.TypeName)); } if (!isExistingBaseType) { this.contentTypes.Add(uppercaseBaseTypeName, baseType); } type.AddBaseType(baseType); } }
/// <summary> /// Creates and adds a new content type with the specified name, or returns the existing type /// </summary> /// <param name="typeName"></param> /// <param name="type">The type created or existent</param> /// <returns>true if the type already existed</returns> private bool GetOrCreateContentType(string typeName, out ContentTypeImpl type) { // Get existing or create new content type if (string.IsNullOrEmpty(typeName)) { throw new ArgumentException(Strings.ContentTypeRegistry_CannotAddTypeWithEmptyTypeName); } string uppercaseTypeName = typeName.ToUpperInvariant(); // no one can produce another unknown content type if (uppercaseTypeName == ContentTypeRegistryImpl.UnknownContentTypeName) { throw new InvalidOperationException(Strings.ContentTypeRegistry_CannotProduceAnotherUnknownType); } bool isExistingType = this.contentTypes.TryGetValue(uppercaseTypeName, out type); if (!isExistingType) { type = new ContentTypeImpl(typeName); } return(isExistingType); }
internal void AddBaseType(ContentTypeImpl baseType) { // TODO: should be part of ctor; this class should be invariant if (!this.BaseTypeList.Contains(baseType)) { this.BaseTypeList.Add(baseType); } }
public IContentType GetContentType(string typeName) { Requires.NotNullOrWhiteSpace(typeName, nameof(typeName)); this.BuildContentTypes(); ContentTypeImpl contentType = null; this.maps.NameToContentTypeMap.TryGetValue(typeName, out contentType); return(contentType); }
public IContentType GetContentType(string typeName) { ContentTypeImpl contentType = null; lock (this.syncLock) { this.BuildContentTypes(); this.contentTypes.TryGetValue(typeName.ToUpperInvariant(), out contentType); } return(contentType); }
public IContentType GetContentType(string typeName) { if (string.IsNullOrWhiteSpace(typeName)) { throw new ArgumentException(nameof(typeName)); } this.BuildContentTypes(); ContentTypeImpl contentType = null; this.maps.NameToContentTypeMap.TryGetValue(typeName, out contentType); return(contentType); }
public IContentType GetContentTypeForFileName(string fileName) { if (fileName == null) { throw new ArgumentNullException(nameof(fileName)); } this.BuildContentTypes(); ContentTypeImpl contentType = null; this.maps.FileNameToContentTypeMap.TryGetValue(fileName, out contentType); // TODO: should we return null if contentType is null? return(contentType ?? ContentTypeRegistryImpl.UnknownContentTypeImpl); }
public IContentType GetContentTypeForExtension(string extension) { if (extension == null) { throw new ArgumentNullException(nameof(extension)); } this.BuildContentTypes(); ContentTypeImpl contentType = null; this.maps.FileExtensionToContentTypeMap.TryGetValue(RemoveExtensionDot(extension), out contentType); // TODO: should we return null if contentType is null? return(contentType ?? ContentTypeRegistryImpl.UnknownContentTypeImpl); }
public void RemoveContentType(string typeName) { lock (this.syncLock) { // Make sure first the content type map is built BuildContentTypes(); } // Since file extension registry will call back the content type registry when it gets initialized, // make sure we force the initialization before obtaining the lock. This will guarantee we won't deadlock // when we'll ask the registered extension later, after we obtained the content types lock FileExtensionRegistry.GetContentTypeForExtension(""); string uppercaseTypeName = typeName.ToUpperInvariant(); lock (this.syncLock) { ContentTypeImpl type = null; if (!this.contentTypes.TryGetValue(uppercaseTypeName, out type)) { // If the type was not registered, removal is successful return; } // Check if the type to be removed is not the Unknown content type if (uppercaseTypeName == ContentTypeRegistryImpl.UnknownContentTypeName) { throw new InvalidOperationException(Strings.ContentTypeRegistry_CannotRemoveTheUnknownType); } // Check if the type is base type for another registered type ContentTypeImpl derivedType; if (IsBaseType(type, out derivedType)) { throw new InvalidOperationException(String.Format(System.Globalization.CultureInfo.CurrentUICulture, Strings.ContentTypeRegistry_CannotRemoveBaseType, type.TypeName, derivedType.TypeName)); } // If there are file extensions using this content type we won't allow removing it IEnumerable <string> extensions = FileExtensionRegistry.GetExtensionsForContentType(type); if (extensions != null && extensions.GetEnumerator().MoveNext()) { throw new InvalidOperationException(String.Format(System.Globalization.CultureInfo.CurrentUICulture, Strings.ContentTypeRegistry_CannotRemoveTypeUsedByFileExtensions, type.TypeName)); } // Remove the content type this.contentTypes.Remove(uppercaseTypeName); } }
public IContentType GetContentTypeForFileName(string fileName) { ContentTypeImpl contentType = null; if (string.IsNullOrWhiteSpace(fileName)) { if (fileName == null) { throw new ArgumentNullException(nameof(fileName)); } } else { this.BuildContentTypes(); this.maps.FileNameToContentTypeMap.TryGetValue(fileName, out contentType); } return(contentType ?? ContentTypeRegistryImpl.UnknownContentTypeImpl); }
public IContentType GetContentTypeForExtension(string extension) { ContentTypeImpl contentType = null; if (string.IsNullOrEmpty(extension)) { if (extension == null) { throw new ArgumentNullException(nameof(extension)); } } else { this.BuildContentTypes(); this.maps.FileExtensionToContentTypeMap.TryGetValue(RemoveExtensionDot(extension), out contentType); } return(contentType ?? ContentTypeRegistryImpl.UnknownContentTypeImpl); }
internal static ContentTypeImpl AddContentTypeFromMetadata(string contentTypeName, string mimeType, IEnumerable <string> baseTypes, IDictionary <string, ContentTypeImpl> nameToContentTypeBuilder, IDictionary <string, ContentTypeImpl> mimeTypeToContentTypeBuilder) { if (!string.IsNullOrEmpty(contentTypeName)) { ContentTypeImpl type; if (!nameToContentTypeBuilder.TryGetValue(contentTypeName, out type)) { bool addToMimeTypeMap = false; if (string.IsNullOrWhiteSpace(mimeType)) { mimeType = MimePrefix + contentTypeName.ToLowerInvariant(); } else if (mimeTypeToContentTypeBuilder.ContainsKey(mimeType)) { mimeType = null; } else { addToMimeTypeMap = true; } type = new ContentTypeImpl(contentTypeName, mimeType, baseTypes); nameToContentTypeBuilder.Add(contentTypeName, type); if (addToMimeTypeMap) { mimeTypeToContentTypeBuilder.Add(mimeType, type); } } else { type.AddUnprocessedBaseTypes(baseTypes); } return(type); } return(null); }
/// <summary> /// Checks whether the specified type is base type for another content type /// </summary> /// <param name="typeToCheck">The type to check for being a base type</param> /// <param name="derivedType">An out parameter to receive the first discovered derived type</param> /// <returns><c>True</c> if the given <paramref name="typeToCheck"/> content type is a base type</returns> private bool IsBaseType(ContentTypeImpl typeToCheck, out ContentTypeImpl derivedType) { derivedType = null; foreach (ContentTypeImpl type in this.maps.NameToContentTypeMap.Values) { if (type != typeToCheck) { foreach (IContentType baseType in type.BaseTypes) { if (baseType == typeToCheck) { derivedType = type; return(true); } } } } return(false); }
public IContentType GetContentTypeForMimeType(string mimeType) { Requires.NotNullOrWhiteSpace(mimeType, nameof(mimeType)); this.BuildContentTypes(); ContentTypeImpl contentType = null; if (!this.maps.MimeTypeToContentTypeMap.TryGetValue(mimeType, out contentType)) { if (mimeType.StartsWith(BaseMimePrefix, StringComparison.Ordinal)) { if (!(mimeType.StartsWith(MimePrefix, StringComparison.Ordinal) && this.maps.NameToContentTypeMap.TryGetValue(mimeType.Substring(MimePrefix.Length), out contentType))) { this.maps.NameToContentTypeMap.TryGetValue(mimeType.Substring(BaseMimePrefix.Length), out contentType); } } } return(contentType); }
/// <summary> /// Checks whether the specified type is base type for another content type /// </summary> /// <param name="typeToCheck">The type to check for being a base type</param> /// <param name="derivedType">An out parameter to receive the first discovered derived type</param> /// <returns><c>True</c> if the given <paramref name="typeToCheck"/> content type is a base type</returns> private bool IsBaseType(ContentTypeImpl typeToCheck, out ContentTypeImpl derivedType) { derivedType = null; foreach (ContentTypeImpl type in contentTypes.Values) { if (type != typeToCheck) { foreach (IContentType baseType in type.BaseTypes) { if (String.Compare(baseType.TypeName, typeToCheck.TypeName, StringComparison.OrdinalIgnoreCase) == 0) { derivedType = type; return(true); } } } } return(false); }
public IContentType GetContentTypeForMimeType(string mimeType) { if (string.IsNullOrWhiteSpace(mimeType)) { throw new ArgumentException(nameof(mimeType)); } this.BuildContentTypes(); ContentTypeImpl contentType = null; if (!this.maps.MimeTypeToContentTypeMap.TryGetValue(mimeType, out contentType)) { if (mimeType.StartsWith(BaseMimePrefix)) { if (!(mimeType.StartsWith(MimePrefix) && this.maps.NameToContentTypeMap.TryGetValue(mimeType.Substring(MimePrefix.Length), out contentType))) { this.maps.NameToContentTypeMap.TryGetValue(mimeType.Substring(BaseMimePrefix.Length), out contentType); } } } return(contentType); }