/// <summary>
/// Create a new classification type and add it to the registry.
/// </summary>
public IClassificationType CreateClassificationType(string type, IEnumerable <IClassificationType> baseTypes)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (baseTypes == null)
{
throw new ArgumentNullException(nameof(baseTypes));
}
if (ClassificationTypes.ContainsKey(type))
{
throw new InvalidOperationException(LookUp.Strings.ClassificationAlreadyAdded);
}
// Use the non-canonical name for the actual type
ClassificationTypeImpl classificationType = new ClassificationTypeImpl(type);
foreach (var baseType in baseTypes)
{
classificationType.AddBaseType(baseType);
}
ClassificationTypes.Add(type, classificationType);
return(classificationType);
}
/// <summary>
/// Consumes all of the IClassificationTypeProvisions in the system to build the
/// list of classification types in the system.
/// </summary>
private void BuildClassificationTypes(Dictionary <string, ClassificationTypeImpl> classificationTypes)
{
// For each content baseType provision, create an IClassificationType.
foreach (Lazy <ClassificationTypeDefinition, IClassificationTypeDefinitionMetadata> classificationTypeDefinition in _classificationTypeDefinitions)
{
string classificationName = classificationTypeDefinition.Metadata.Name;
ClassificationTypeImpl type = null;
if (!classificationTypes.TryGetValue(classificationName, out type))
{
type = new ClassificationTypeImpl(classificationName);
classificationTypes.Add(classificationName, type);
}
IEnumerable <string> baseTypes = classificationTypeDefinition.Metadata.BaseDefinition;
if (baseTypes != null)
{
ClassificationTypeImpl baseType = null;
foreach (string baseClassificationType in baseTypes)
{
if (!classificationTypes.TryGetValue(baseClassificationType, out baseType))
{
baseType = new ClassificationTypeImpl(baseClassificationType);
classificationTypes.Add(baseClassificationType, baseType);
}
type.AddBaseType(baseType);
}
}
}
}
public IClassificationType GetClassificationType(string type)
{
ClassificationTypeImpl classificationType = null;
this.ClassificationTypes.TryGetValue(type, out classificationType);
return(classificationType);
}
/// <summary>
/// Builds a new transient classification type based on a set of actual base
/// types.
///
/// With multiple projection buffers, it is possible to have a transient classification
/// type with transient types as parents.
/// </summary>
/// <param name="baseTypes"></param>
/// <returns></returns>
private IClassificationType BuildTransientClassificationType(IEnumerable <IClassificationType> baseTypes)
{
// Lazily init
if (_transientClassificationTypes == null)
{
_transientClassificationTypes = new Dictionary <string, ClassificationTypeImpl>(StringComparer.OrdinalIgnoreCase);
}
List <IClassificationType> sortedBaseTypes = new List <IClassificationType>(baseTypes);
sortedBaseTypes.Sort(delegate(IClassificationType a, IClassificationType b)
{ return(string.CompareOrdinal(a.Classification, b.Classification)); });
// Build the transient name
StringBuilder sb = new StringBuilder();
foreach (IClassificationType type in sortedBaseTypes)
{
sb.Append(type.Classification);
sb.Append(" - ");
}
// Append "(transient)" onto the name.
sb.Append(this.TransientClassificationType.Classification);
// Look for a cached type
ClassificationTypeImpl transientType;
if (!_transientClassificationTypes.TryGetValue(sb.ToString(), out transientType))
{
// Didn't find a cached type, so create a new one
transientType = new ClassificationTypeImpl(sb.ToString());
foreach (IClassificationType type in sortedBaseTypes)
{
transientType.AddBaseType(type);
}
// Add in the transient type as a base type
transientType.AddBaseType(TransientClassificationType);
// Cache this type so it doesn't need to be created again.
_transientClassificationTypes[transientType.Classification] = transientType;
}
return(transientType);
}
