private static MyParameterInfo FindParameter(MyDelegateInfo myDelegateInfo, string paramName)
{
if (!myDelegateInfo.Parameters.ContainsKey(paramName))
{
return(null);
}
return(myDelegateInfo.Parameters[paramName]);
}
private void ProcessMemberNode(XPathNavigator memberNodeNavigator, XPathNavigator docNavigator)
{
string nameAttribValue = memberNodeNavigator.GetAttribute("name", "");
string xmlMemberId = nameAttribValue.Substring(2);
char memberType = nameAttribValue[0];
switch (memberType)
{
case 'T':
{
MyClassInfo myClassInfo = FindNamespaceMember(xmlMemberId);
if (myClassInfo == null)
{
Logger.Warning("(XML) Couldn't locate namespace member '{0}'.", xmlMemberId);
break;
}
myClassInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myClassInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
if (myClassInfo.IsNested)
{
// the class/struct/etc. is a nested typeDefinition
int indexOfLastDot = xmlMemberId.LastIndexOf('.');
Debug.Assert(indexOfLastDot != -1, "There must be dot because this type is nested.");
string declaringTypeFullName = xmlMemberId.Substring(0, indexOfLastDot);
MyClassInfo declaringType = FindNamespaceMember(declaringTypeFullName);
if (declaringType == null)
{
// Declaring type of a nested type is private
break;
}
MyNestedTypeInfo myNestedTypeInfo = declaringType.GetNestedTypeMember(myClassInfo);
Debug.Assert(myNestedTypeInfo != null, "Impossible! This nested type must be there.");
myNestedTypeInfo.Summary = myClassInfo.Summary;
}
if (myClassInfo is MyDelegateInfo)
{
MyDelegateInfo myDelegateInfo = (MyDelegateInfo)myClassInfo;
// returns node
string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "returns");
if (myDelegateInfo.ReturnTypeFullName.ToLower() != "system.void")
{
myDelegateInfo.ReturnValueSummary = returnValueSummary;
}
else if (returnValueSummary != "")
{
Logger.Warning("(XML) There's a description of return value for delegate '{0}' but this delegate returns nothing.", xmlMemberId);
}
// param nodes
XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
while (paramNodes.MoveNext())
{
string paramName = paramNodes.Current.GetAttribute("name", "");
if (paramName == null)
{
Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
continue;
}
MyParameterInfo myParameterInfo = FindParameter(myDelegateInfo, paramName);
if (myParameterInfo == null)
{
Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
continue;
}
myParameterInfo.Summary = paramNodes.Current.InnerXml;
}
}
// typeparam nodes
XPathNodeIterator typeParamNodes = memberNodeNavigator.Select("typeparam");
while (typeParamNodes.MoveNext())
{
string typeParamName = typeParamNodes.Current.GetAttribute("name", "");
if (typeParamName == null)
{
Logger.Warning("(XML) Node 'typeparam' doesn't have required attribute 'name'.");
continue;
}
MyGenericParameterInfo myGenericParameterInfo = FindGenericParameter(myClassInfo, typeParamName);
if (myGenericParameterInfo == null)
{
Logger.Warning("(XML) Node 'typeparam' with name '{0}' referenced in XML documentation couldn't be found in type '{1}'.", typeParamName, xmlMemberId);
continue;
}
myGenericParameterInfo.Summary = typeParamNodes.Current.InnerXml;
}
myClassInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case 'M':
{
MyInvokableMemberInfo myInvokableMemberInfo = FindMethodOrConstructor(xmlMemberId);
if (myInvokableMemberInfo == null)
{
Logger.Warning("(XML) Couldn't locate invokable member '{0}'.", xmlMemberId);
break;
}
myInvokableMemberInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myInvokableMemberInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
if (myInvokableMemberInfo is MyMethodInfo)
{
MyMethodInfo myMethodInfo = (MyMethodInfo)myInvokableMemberInfo;
// returns node
string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "returns");
if (myMethodInfo.ReturnTypeFullName.ToLower() != "system.void")
{
myMethodInfo.ReturnValueSummary = returnValueSummary;
}
else if (returnValueSummary != "")
{
Logger.Warning("(XML) There's a description of return value for method '{0}' but this method/constructor returns nothing.", xmlMemberId);
}
// typeparam nodes
XPathNodeIterator typeParamNodes = memberNodeNavigator.Select("typeparam");
while (typeParamNodes.MoveNext())
{
string typeParamName = typeParamNodes.Current.GetAttribute("name", "");
if (typeParamName == null)
{
Logger.Warning("(XML) Node 'typeparam' doesn't have required attribute 'name'.");
continue;
}
MyGenericParameterInfo myGenericParameterInfo = FindGenericParameter(myMethodInfo, typeParamName);
if (myGenericParameterInfo == null)
{
Logger.Warning("(XML) Node 'typeparam' with name '{0}' referenced in XML documentation couldn't be found in type '{1}'.", typeParamName, xmlMemberId);
continue;
}
myGenericParameterInfo.Summary = typeParamNodes.Current.InnerXml;
}
}
// param nodes
XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
while (paramNodes.MoveNext())
{
string paramName = paramNodes.Current.GetAttribute("name", "");
if (paramName == null)
{
Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
continue;
}
MyParameterInfo myParameterInfo = FindParameter(myInvokableMemberInfo, paramName);
if (myParameterInfo == null)
{
Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
continue;
}
myParameterInfo.Summary = paramNodes.Current.InnerXml;
}
// exception nodes
XPathNodeIterator exceptionNodes = memberNodeNavigator.Select("exception");
while (exceptionNodes.MoveNext())
{
string exceptionCref = exceptionNodes.Current.GetAttribute("cref", "");
if (exceptionCref == null)
{
Logger.Warning("(XML) Node 'exception' doesn't have required attribute 'cref'.");
continue;
}
int indexOfColon = exceptionCref.IndexOf(':');
if (indexOfColon != -1 && indexOfColon + 1 < exceptionCref.Length)
{
exceptionCref = exceptionCref.Substring(indexOfColon + 1);
}
MyClassInfo exceptionClassInfo = FindGlobalNamespaceMember(exceptionCref);
if (exceptionClassInfo != null)
{
myInvokableMemberInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionClassInfo, exceptionNodes.Current.InnerXml));
}
else
{
myInvokableMemberInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionCref, exceptionNodes.Current.InnerXml));
}
}
// example nodes
myInvokableMemberInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case 'F':
{
MyFieldInfo myFieldInfo = FindField(xmlMemberId);
if (myFieldInfo == null)
{
Logger.Warning("(XML) Couldn't locate field '{0}'.", xmlMemberId);
break;
}
myFieldInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myFieldInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
myFieldInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case 'P':
{
MyPropertyInfo myPropertyInfo = FindProperty(xmlMemberId);
if (myPropertyInfo == null)
{
Logger.Warning("(XML) Couldn't locate property '{0}'.", xmlMemberId);
break;
}
myPropertyInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myPropertyInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
string returnValueSummary = ReadXmlNodes(memberNodeNavigator, "value");
myPropertyInfo.ReturnValueSummary = returnValueSummary;
// param nodes
XPathNodeIterator paramNodes = memberNodeNavigator.Select("param");
while (paramNodes.MoveNext())
{
string paramName = paramNodes.Current.GetAttribute("name", "");
if (paramName == null)
{
Logger.Warning("(XML) Node 'param' doesn't have required attribute 'name'.");
continue;
}
MyParameterInfo myParameterInfo = FindParameter(myPropertyInfo, paramName);
if (myParameterInfo == null)
{
Logger.Warning("(XML) Node 'param' with name '{0}' referenced in XML documentation couldn't be found in method/constructor '{1}'.", paramName, xmlMemberId);
continue;
}
myParameterInfo.Summary = paramNodes.Current.InnerXml;
}
// exception nodes
XPathNodeIterator exceptionNodes = memberNodeNavigator.Select("exception");
while (exceptionNodes.MoveNext())
{
string exceptionCref = exceptionNodes.Current.GetAttribute("cref", "");
if (exceptionCref == null)
{
Logger.Warning("(XML) Node 'exception' doesn't have required attribute 'cref'.");
continue;
}
int indexOfColon = exceptionCref.IndexOf(':');
if (indexOfColon != -1 && indexOfColon + 1 < exceptionCref.Length)
{
exceptionCref = exceptionCref.Substring(indexOfColon + 1);
}
MyClassInfo exceptionClassInfo = FindGlobalNamespaceMember(exceptionCref);
if (exceptionClassInfo != null)
{
myPropertyInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionClassInfo, exceptionNodes.Current.InnerXml));
}
else
{
myPropertyInfo.ExceptionsDescrs.Add(new ExceptionDescr(exceptionCref, exceptionNodes.Current.InnerXml));
}
}
myPropertyInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case 'E':
{
MyEventInfo myEventInfo = FindEvent(xmlMemberId);
if (myEventInfo == null)
{
Logger.Warning("(XML) Couldn't locate event '{0}'.", xmlMemberId);
break;
}
myEventInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
myEventInfo.Remarks = ReadXmlNodes(memberNodeNavigator, "remarks");
myEventInfo.Example = ReadXmlNodes(memberNodeNavigator, "example");
break;
}
case '!':
{
// shouldn't normally happen; exclamation mark is not used in members
// but for example in crefs
Logger.Warning("(XML) There is a member which couldn't be resolved by Visual Studio: '{0}'.", xmlMemberId);
break;
}
case 'N':
{
// shouldn't normally happen; namespaces can't normally have comments
// but for example documentation files for .NET Framework contain such members (sic!)
MyNamespaceInfo myNamespaceInfo = FindNamespace(xmlMemberId);
if (myNamespaceInfo == null)
{
Logger.Warning("(XML) Couldn't locate namespace '{0}'.", xmlMemberId);
break;
}
myNamespaceInfo.Summary = ReadXmlNodes(memberNodeNavigator, "summary");
break;
}
default:
{
Logger.Warning("Couldn't recognize type of a member ('{0}').", memberType);
break;
}
}
}
public void AddType(TypeDefinition typeDefinition)
{
if (typeDefinition.IsValueType && !typeDefinition.IsEnum)
{
MyStructureInfo myStructureInfo = new MyStructureInfo(typeDefinition, assemblyName);
Dictionary <string, MetaClass> membersGroup;
NamespaceMembersGroups namespaceMembersGroupType;
if (myStructureInfo.IsPublic)
{
namespaceMembersGroupType = NamespaceMembersGroups.PublicStructures;
}
else if (myStructureInfo.IsProtectedInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalStructures;
}
else if (myStructureInfo.IsProtected)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedStructures;
}
else if (myStructureInfo.IsInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.InternalStructures;
}
else if (myStructureInfo.IsPrivate)
{
namespaceMembersGroupType = NamespaceMembersGroups.PrivateStructures;
}
else
{
Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
return;
}
membersGroup = GetMembersGroup(namespaceMembersGroupType);
if (!membersGroup.ContainsKey(myStructureInfo.Name))
{
membersGroup.Add(myStructureInfo.Name, myStructureInfo);
AddGenericNameMappingIfNeeded(myStructureInfo, namespaceMembersGroupType);
}
else
{
Logger.Warning("Structure named '{0}' has already been added to namespace {1}.", myStructureInfo.Name, name);
}
}
else if (typeDefinition.IsInterface)
{
MyInterfaceInfo myInterfaceInfo = new MyInterfaceInfo(typeDefinition, assemblyName);
Dictionary <string, MetaClass> membersGroup;
NamespaceMembersGroups namespaceMembersGroupType;
if (myInterfaceInfo.IsPublic)
{
namespaceMembersGroupType = NamespaceMembersGroups.PublicInterfaces;
}
else if (myInterfaceInfo.IsProtectedInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalInterfaces;
}
else if (myInterfaceInfo.IsProtected)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInterfaces;
}
else if (myInterfaceInfo.IsInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.InternalInterfaces;
}
else if (myInterfaceInfo.IsPrivate)
{
namespaceMembersGroupType = NamespaceMembersGroups.PrivateInterfaces;
}
else
{
Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
return;
}
membersGroup = GetMembersGroup(namespaceMembersGroupType);
if (!membersGroup.ContainsKey(myInterfaceInfo.Name))
{
membersGroup.Add(myInterfaceInfo.Name, myInterfaceInfo);
AddGenericNameMappingIfNeeded(myInterfaceInfo, namespaceMembersGroupType);
}
else
{
Logger.Warning("Interface named '{0}' has already been added to namespace {1}.", myInterfaceInfo.Name, name);
}
}
else if (typeDefinition.IsEnum)
{
MyEnumerationInfo myEnumerationInfo = new MyEnumerationInfo(typeDefinition, assemblyName);
Dictionary <string, MetaClass> membersGroup;
NamespaceMembersGroups namespaceMembersGroupType;
if (myEnumerationInfo.IsPublic)
{
namespaceMembersGroupType = NamespaceMembersGroups.PublicEnumerations;
}
else if (myEnumerationInfo.IsProtectedInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalEnumerations;
}
else if (myEnumerationInfo.IsProtected)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedEnumerations;
}
else if (myEnumerationInfo.IsInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.InternalEnumerations;
}
else if (myEnumerationInfo.IsPrivate)
{
namespaceMembersGroupType = NamespaceMembersGroups.PrivateEnumerations;
}
else
{
Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
return;
}
membersGroup = GetMembersGroup(namespaceMembersGroupType);
if (!membersGroup.ContainsKey(myEnumerationInfo.Name))
{
membersGroup.Add(myEnumerationInfo.Name, myEnumerationInfo);
AddGenericNameMappingIfNeeded(myEnumerationInfo, namespaceMembersGroupType);
}
else
{
Logger.Warning("Enumeration named '{0}' has already been added to namespace {1}.", myEnumerationInfo.Name, name);
}
}
else if (typeDefinition.IsClass && !Utils.IsDelegate(typeDefinition))
{
MyClassInfo myClassInfo = new MyClassInfo(typeDefinition, assemblyName);
Dictionary <string, MetaClass> membersGroup;
NamespaceMembersGroups namespaceMembersGroupType;
if (myClassInfo.IsPublic)
{
namespaceMembersGroupType = NamespaceMembersGroups.PublicClasses;
}
else if (myClassInfo.IsProtectedInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalClasses;
}
else if (myClassInfo.IsProtected)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedClasses;
}
else if (myClassInfo.IsInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.InternalClasses;
}
else if (myClassInfo.IsPrivate)
{
namespaceMembersGroupType = NamespaceMembersGroups.PrivateClasses;
}
else
{
Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
return;
}
membersGroup = GetMembersGroup(namespaceMembersGroupType);
if (!membersGroup.ContainsKey(myClassInfo.Name))
{
membersGroup.Add(myClassInfo.Name, myClassInfo);
AddGenericNameMappingIfNeeded(myClassInfo, namespaceMembersGroupType);
}
else
{
Logger.Warning("Class named '{0}' has already been added to namespace {1}.", myClassInfo.Name, name);
}
}
else if (Utils.IsDelegate(typeDefinition))
{
MyDelegateInfo myDelegateInfo = new MyDelegateInfo(typeDefinition, assemblyName);
Dictionary <string, MetaClass> membersGroup;
NamespaceMembersGroups namespaceMembersGroupType;
if (myDelegateInfo.IsPublic)
{
namespaceMembersGroupType = NamespaceMembersGroups.PublicDelegates;
}
else if (myDelegateInfo.IsProtectedInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedInternalDelegates;
}
else if (myDelegateInfo.IsProtected)
{
namespaceMembersGroupType = NamespaceMembersGroups.ProtectedDelegates;
}
else if (myDelegateInfo.IsInternal)
{
namespaceMembersGroupType = NamespaceMembersGroups.InternalDelegates;
}
else if (myDelegateInfo.IsPrivate)
{
namespaceMembersGroupType = NamespaceMembersGroups.PrivateDelegates;
}
else
{
Debug.Assert(false, "Impossible! Visibility of a type is not supported.");
return;
}
membersGroup = GetMembersGroup(namespaceMembersGroupType);
if (!membersGroup.ContainsKey(myDelegateInfo.Name))
{
membersGroup.Add(myDelegateInfo.Name, myDelegateInfo);
AddGenericNameMappingIfNeeded(myDelegateInfo, namespaceMembersGroupType);
}
else
{
Logger.Warning("Delegate named '{0}' has already been added to namespace {1}.", myDelegateInfo.Name, name);
}
}
else
{
Logger.Warning("Unrecognized type: {0}.", typeDefinition.FullName);
}
}