private static MyParameterInfo FindParameter(MyPropertyInfo myPropertyInfo, string paramName)
{
if (!myPropertyInfo.Parameters.ContainsKey(paramName))
{
return(null);
}
return(myPropertyInfo.Parameters[paramName]);
}
private string GetMyPropertyInfoVisibilitModifiersCodeString(MyPropertyInfo myPropertyInfo)
{
if (myPropertyInfo.IsPublic) { return "Public"; }
else if (myPropertyInfo.IsProtectedInternal) { return "ProtectedInternal"; }
else if (myPropertyInfo.IsProtected) { return "Protected"; }
else if (myPropertyInfo.IsInternal) { return "Internal"; }
else if (myPropertyInfo.IsPrivate) { return "Private"; }
throw new Exception("Impossible!");
}
private string ResolvePropertyLink(MyPropertyInfo myPropertyInfo, MyClassInfo declaringType,
int indexInOverloadsList)
{
string prefix = "P_" + GetMyPropertyInfoVisibilitModifiersCodeString(myPropertyInfo) + "_";
string namespaceDirName = GetNamespaceDirName(declaringType.Namespace);
return GetAliasName(declaringType.AssemblyName + "_" + declaringType.AssemblyName.GetHashCode()
+ Path.DirectorySeparatorChar + namespaceDirName
+ Path.DirectorySeparatorChar + CLASS_MEMBERS_DIRECTORY
+ Path.DirectorySeparatorChar + declaringType.Name + "_" + declaringType.Name.GetHashCode()
+ Path.DirectorySeparatorChar + prefix + myPropertyInfo.Name + "_" + indexInOverloadsList + "_" + myPropertyInfo.Name.GetHashCode() + ".html",
true, true);
}
private string CreatePropertySyntaxString(MyPropertyInfo myPropertyInfo)
{
string returnType = " " + ProcessType(((MyPropertyInfo)myPropertyInfo).TypeFullName);
string name = myPropertyInfo.ParametersNames.Count > 0 ? "this" : Utils.HTMLEncode(myPropertyInfo.DisplayableName);
string getSetString;
if (myPropertyInfo.HasGetter && myPropertyInfo.HasSetter) { getSetString = "{ get; set; }"; }
else if (myPropertyInfo.HasGetter) { getSetString = "{ get; }"; }
else { getSetString = "{ set; }"; }
return CreateInvokableMemberOrDelegateSyntaxString(myPropertyInfo.AttributesString,
returnType,
name,
myPropertyInfo.ParametersNames,
myPropertyInfo.Parameters,
null,
'[', ']', true,
getSetString);
}
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);
Debug.Assert(declaringType != null, "Declaring type of a nested type must be present.");
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;
}
}
}
protected virtual void AddProperty(PropertyDefinition propertyDefinition)
{
MyPropertyInfo myPropertyInfo = new MyPropertyInfo(propertyDefinition, this);
Dictionary<string, MetaClass> membersGroup;
if (myPropertyInfo.IsPublic)
{
membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.PublicPropertiesOverloads);
}
else if (myPropertyInfo.IsProtectedInternal)
{
membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.ProtectedInternalPropertiesOverloads);
}
else if (myPropertyInfo.IsProtected)
{
membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.ProtectedPropertiesOverloads);
}
else if (myPropertyInfo.IsInternal)
{
membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.InternalPropertiesOverloads);
}
else if (myPropertyInfo.IsPrivate)
{
membersGroup = CreateAndGetMembersGroup(ClassMembersGroups.PrivatePropertiesOverloads);
}
else
{
Debug.Assert(false, "Impossible! Visibility of a member is not supported.");
return;
}
MyPropertiesOverloadsInfo propertiesOverloads;
if (!membersGroup.ContainsKey(myPropertyInfo.Name))
{
propertiesOverloads = new MyPropertiesOverloadsInfo(myPropertyInfo.Name);
membersGroup[myPropertyInfo.Name] = propertiesOverloads;
}
else
{
propertiesOverloads = (MyPropertiesOverloadsInfo)membersGroup[myPropertyInfo.Name];
}
propertiesOverloads.AddProperty(myPropertyInfo);
}
private static MyParameterInfo FindParameter(MyPropertyInfo myPropertyInfo, string paramName)
{
if (!myPropertyInfo.Parameters.ContainsKey(paramName))
{
return null;
}
return myPropertyInfo.Parameters[paramName];
}