//=====================================================================
/// <summary>
/// Check to see if the type is required or not by this entry
/// </summary>
/// <param name="type">The type to check</param>
/// <returns>Null if the type is not within the namespace of this entry, true if it is and it is required
/// or false if it is and it is not required.</returns>
public bool? IsRequiredType(TypeNode type)
{
if(this.IsExposedNamespace(type.GetNamespace()) != null)
{
foreach(TypeFilter typeFilter in typeFilters)
{
bool? result = typeFilter.IsRequiredType(type);
if(result != null)
return result;
}
// No filters match so it's not required
return false;
}
return null;
}
/// <summary>
/// This is used to find out if the given type is in this namespace and has any exposed members
/// </summary>
/// <param name="type">The type to check</param>
/// <returns>True if the type is in this namespace and has exposed members, false if not</returns>
public bool HasExposedMembers(TypeNode type)
{
if(this.IsExposedNamespace(type.GetNamespace()) != null)
foreach(TypeFilter typeFilter in typeFilters)
{
bool? result = typeFilter.IsExposedType(type);
if(result != null)
return typeFilter.HasExposedMembers(type);
}
return false;
}
/// <summary>
/// Write out type containers
/// </summary>
/// <param name="type">The type for which to write out containers</param>
private void WriteTypeContainers(TypeNode type)
{
writer.WriteStartElement("containers");
this.WriteLibraryReference(type.DeclaringModule);
this.WriteNamespaceReference(type.GetNamespace());
// For nested types, record outer types
TypeNode outer = type.DeclaringType;
if(outer != null)
this.WriteTypeReference(outer);
writer.WriteEndElement();
}
/// <summary>
/// Check to see if the type is exposed or not by this entry
/// </summary>
/// <param name="type">The type to check</param>
/// <returns>Null if the type is not within the namespace of this entry, true if it is and it is exposed
/// or false if it is and it is not exposed.</returns>
public bool? IsExposedType(TypeNode type)
{
if(this.IsExposedNamespace(type.GetNamespace()) != null)
{
foreach(TypeFilter typeFilter in typeFilters)
{
bool? result = typeFilter.IsExposedType(type);
if(result != null)
return result;
}
// No filter matches for this type, check the parents since it could be nested
TypeNode parent = type.DeclaringType;
while(parent != null)
{
bool? parentExposed = this.IsExposedType(parent);
if(parentExposed != null)
return parentExposed;
parent = type.DeclaringType;
}
// No filters match for the parents either, use the namespace setting
return exposed;
}
return null;
}
/// <summary>
/// Write out member containers
/// </summary>
/// <param name="type">The declaring type of the member</param>
private void WriteMemberContainers(TypeNode type)
{
writer.WriteStartElement("containers");
this.WriteLibraryReference(type.DeclaringModule);
this.WriteNamespaceReference(type.GetNamespace());
this.WriteTypeReference(type);
writer.WriteEndElement();
}