public override bool Equals(IIntermediateType other)
{
if (other == null)
{
return(false);
}
if (base.Equals(other))
{
return(true);
}
if (this.IsGenericConstruct && other.IsGenericConstruct)
{
if (!(other is IGenericType))
{
return(false);
}
IGenericType otherGeneric = (IGenericType)other;
if (this.GenericParameters.Count != otherGeneric.GenericParameters.Count)
{
return(false);
}
if (otherGeneric.IsGenericDefinition)
{
return(false);
}
return(otherGeneric.GenericParameters.SequenceEqual(this.GenericParameters));
}
return(false);
}
private string VisitIntermediateType(IIntermediateType intermediateType, IntermediateNameRequestDetails context)
{
string name = null;
switch (context)
{
case IntermediateNameRequestDetails.TargetFileName:
this.fileNameLookup.TryGetValue(intermediateType.Assembly, out name);
if (this.HtmlContext)
{
name = string.Format("{0}#type{1:X8}", name, intermediateType.GetHashCode());
}
break;
case IntermediateNameRequestDetails.SourceFileName:
name = intermediateType.Assembly.FileName;
break;
case IntermediateNameRequestDetails.DisplayName:
name = intermediateType.Name;
break;
case IntermediateNameRequestDetails.ReferenceName:
if (this.HtmlContext)
{
name = string.Format("type{0:X8}", intermediateType.GetHashCode());
}
break;
}
return(name);
}
private void DefineDeclaration(IIntermediateType declaration)
{
if (HasNameHandler)
{
this.EndSpan();
this.HandleWriteInternal(string.Format("<a class=\"def\" name=\"{0}\">", declaration.Accept(this.translator.NameProvider, IntermediateNameRequestDetails.ReferenceName)));
}
}
private void ReferenceDeclaration(IIntermediateType declaration)
{
if (this.HasNameHandler)
{
EndSpan();
string name = declaration.Accept(this.translator.NameProvider, IntermediateNameRequestDetails.TargetFileName);
TranslateRelativePath(name);
referenceStack.Push(declaration);
}
}
/// <summary>
/// Returns whether the <see cref="IntermediateTypeBase{TTypeIdentifier, TType, TIntermediateType}"/> is equal to the
/// <paramref name="other"/> type.
/// </summary>
/// <param name="other">The intermediate type to check against.</param>
/// <returns>true if the current type is the <paramref name="other"/> type.</returns>
public virtual bool Equals(IIntermediateType other)
{
return(object.ReferenceEquals(this, other));
}
public IEnumerator <IMetadatum> GetEnumerator()
{
Dictionary <IType, MetadatumInfo> usageInformation = new Dictionary <IType, MetadatumInfo>();
List <IType> singleUseMetadata = new List <IType>();
List <IIntermediateType> listenedTypes = new List <IIntermediateType>();
if (currentType == null)
{
yield break;
}
try
{
while (currentType != null)
{
currentType.BaseTypeChanged += currentType_BaseTypeChanged;
lock (syncObject)
listenedTypes.Add(currentType);
ChangeCheck();
var metadataSet = currentType.Metadata;
foreach (var metadata in metadataSet)
{
ChangeCheck();
bool first = true;
foreach (var metadatum in metadata)
{
if (first)
{
first = false;
}
else
{
ChangeCheck();
}
MetadatumInfo usage;
if (!usageInformation.TryGetValue(metadatum.Type, out usage))
{
usageInformation.Add(metadatum.Type, usage = currentType.IdentityManager.MetadatumHandler.GetMetadatumInfo(metadatum.Type));
}
if (usage.MetadatumRepresentation == TypeMetadatumRepresentation.IsNotMetadata)
{
continue;
}
if (!usage.Repeatable)
{
if (singleUseMetadata.Contains(metadatum.Type))
{
continue;
}
singleUseMetadata.Add(metadatum.Type);
}
yield return(metadatum);
}
}
var nextType = currentType.BaseType;
currentType = nextType as IIntermediateType;
}
}
finally
{
Unlisten();
}
}
public Enumerator(IIntermediateType parent)
{
this.currentType = parent;
}
public void Dispose()
{
this.parent = null;
GC.SuppressFinalize(this);
}
/// <summary>
/// Creates a new <see cref="IntermediateTypeMetadataCollection"/>
/// with the <paramref name="parent"/> provided.
/// </summary>
/// <param name="parent">The <see cref="IIntermediateType"/> which needs
/// a merged series of custom attributes.</param>
public IntermediateTypeMetadataCollection(IIntermediateType parent)
{
this.parent = parent;
}
