/// <summary>
/// Thiashd iahsd haishd iashd ihasih iqwhei hqie hwqih eoqwh eoqwihe oashd
/// oasihd o oiahsd oihasd oihawoidh aowihd oaihd oiahsoid had asd .as.d as. d
/// as.d a sd as.
/// </summary>
/// <param name="fieldDefinition"></param>
/// <param name="declaringType"></param>
public MyFieldInfo(FieldDefinition fieldDefinition, MyClassInfo declaringType)
: base()
{
this.name = fieldDefinition.Name;
string[] readableForms = Tools.GetHumanReadableForms(fieldDefinition.FieldType);
this.typeFullName = readableForms[0];
this.typeFullNameWithoutRevArrayStrings = readableForms[1];
this.attributes = GetMyFieldAttributes(fieldDefinition);
this.declaringType = declaringType;
if ((fieldDefinition.Attributes & FieldAttributes.HasDefault) != 0)
{
try
{
object rawConstant = fieldDefinition.Constant;
defaultValue = rawConstant == null ? null : rawConstant.ToString();
}
catch (Exception)
{
Logger.Warning("Couldn't obtain default value for field '{0}'.", name);
}
}
this.CheckSupport(fieldDefinition.Attributes);
}
public MyPropertyInfo(PropertyDefinition propertyDefinition, MyClassInfo declaringType)
: base()
{
this.name = propertyDefinition.Name;
string[] readableForms = Tools.GetHumanReadableForms(propertyDefinition.PropertyType);
this.typeFullName = readableForms[0];
this.typeFullNameWithoutRevArrayStrings = readableForms[1];
this.declaringType = declaringType;
MethodDefinition getterInfo = propertyDefinition.GetMethod;
MethodDefinition setterInfo = propertyDefinition.SetMethod;
this.hasGetter = getterInfo != null;
this.hasSetter = setterInfo != null;
MethodDefinition getterOrSetterInfo = getterInfo != null ? getterInfo : setterInfo;
Debug.Assert(getterOrSetterInfo != null, "Impossible! Property must have either getter or setter or both.");
this.attributes = GetMyPropertyAttributes(propertyDefinition);
this.underlyingMethodsAttributes = GetMyInvokableMemberAttributes(getterOrSetterInfo);
this.parametersNames = new List<string>();
this.parameters = new Dictionary<string, MyParameterInfo>();
this.exceptionsDescrs = new List<ExceptionDescr>();
AddParameters(getterInfo, setterInfo);
this.CheckSupport(propertyDefinition.Attributes, getterOrSetterInfo.Attributes);
}
public MyConstructorInfo(MethodDefinition constructorDefinition, MyClassInfo declaringType)
: base(constructorDefinition, declaringType)
{
this.name = declaringType.Name;
this.CheckSupport(constructorDefinition.Attributes);
AddParameters(constructorDefinition.Parameters);
}
protected MyInvokableMemberInfo(MethodDefinition methodDefinition, MyClassInfo declaringType)
{
this.attributes = GetMyInvokableMemberAttributes(methodDefinition);
this.declaringType = declaringType;
this.summary = String.Empty;
this.parametersNames = new List<string>();
this.parameters = new Dictionary<string, MyParameterInfo>();
this.exceptionsDescrs = new List<ExceptionDescr>();
}
public ExceptionDescr(string exceptionCref, string condition)
{
if (exceptionCref == null)
{
throw new ArgumentNullException("exceptionCref");
}
if (condition == null)
{
throw new ArgumentNullException("condition");
}
this.exceptionClassInfo = null;
this.typeFullName = exceptionCref;
this.condition = condition;
}
public MyEventInfo(EventDefinition eventDefinition, MyClassInfo declaringType)
: base()
{
this.name = eventDefinition.Name;
string[] readableForms = Tools.GetHumanReadableForms(eventDefinition.EventType);
this.typeFullName = readableForms[0];
this.typeFullNameWithoutRevArrayStrings = readableForms[1];
this.declaringType = declaringType;
MethodDefinition adderInfo = eventDefinition.AddMethod;
Debug.Assert(adderInfo != null, "Impossible! add_Event() must have been generated.");
this.attributes = GetMyEventAttributes(eventDefinition);
this.underlyingMethodsAttributes = GetMyInvokableMemberAttributes(adderInfo);
this.CheckSupport(eventDefinition, adderInfo.Attributes);
}
public MyNestedTypeInfo(TypeDefinition typeDefinition, MyClassInfo declaringType)
: base()
{
Debug.Assert(Utils.IsTypeNested(typeDefinition), "Impossible! Given type is not a nested type.");
string[] readableForms = Tools.GetHumanReadableForms(typeDefinition);
this.name = readableForms[0];
int indexOfLastSlash = this.name.LastIndexOf('/');
Debug.Assert(indexOfLastSlash != -1 && indexOfLastSlash + 1 < this.Name.Length, "Impossible! This is a nested type.");
this.name = this.name.Substring(indexOfLastSlash + 1);
this.attributes = MyClassInfo.GetMyClassAttributes(typeDefinition);
this.declaringType = declaringType;
this.metaType = GetMetaType(typeDefinition);
if (metaType == NestedTypes.Unknown)
{
Logger.Warning("Unrecognized meta type of '{0}'", typeDefinition.FullName);
}
}
public MyMethodInfo(MethodDefinition methodDefinition, MyClassInfo declaringType)
: base(methodDefinition, declaringType)
{
this.name = null;
if ((methodDefinition.Attributes & MethodAttributes.SpecialName) != 0)
{
if (MethodsNamesMappings.ContainsKey(methodDefinition.Name))
{
this.name = MethodsNamesMappings[methodDefinition.Name];
}
}
if (this.name == null)
{
this.name = methodDefinition.Name;
}
if (Utils.IsGenericMethod(methodDefinition))
{
Tools.ExamineGenericParameters(methodDefinition.GenericParameters, null, out genericParameters);
}
if (genericParameters != null && genericParameters.Count > 0)
{
this.name += Tools.CreateFormalGenericParametersString(genericParameters);
}
string[] readableForms = Tools.GetHumanReadableForms(methodDefinition.ReturnType);
this.returnTypeFullName = readableForms[0];
this.returnTypeFullNameWithoutRevArrayStrings = readableForms[1];
this.CheckSupport(methodDefinition.Attributes);
AddParameters(methodDefinition.Parameters);
}
public ExceptionDescr(MyClassInfo exceptionClassInfo, string condition)
{
if (exceptionClassInfo == null)
{
throw new ArgumentNullException("exceptionClassInfo");
}
if (condition == null)
{
throw new ArgumentNullException("condition");
}
if (exceptionClassInfo.Namespace == null || exceptionClassInfo.Namespace == "")
{
this.typeFullName = exceptionClassInfo.Name;
}
else
{
this.typeFullName = exceptionClassInfo.Namespace + "." + exceptionClassInfo.Name;
}
this.exceptionClassInfo = exceptionClassInfo;
this.condition = condition;
}
private void ProcessEvent(MyEventInfo myEventInfo, MyClassInfo declaringType, string dirName)
{
string syntax = String.Format("{0} event {1} {2}", myEventInfo.AttributesString,
ProcessType(myEventInfo.TypeFullName),
myEventInfo.DisplayableName);
ProcessFieldOrEvent("E_", myEventInfo.Name, "Field", declaringType, dirName,
myEventInfo.Summary, myEventInfo.Remarks, syntax, myEventInfo.Example);
}
private void ProcessField(MyFieldInfo myFieldInfo, MyClassInfo declaringType, string dirName)
{
string constValue = "";
if (myFieldInfo.IsConst)
{
if (myFieldInfo.ConstantValue == null)
{
constValue = " = null";
}
else if (myFieldInfo.TypeFullName.ToLower() == "system.string")
{
constValue = " = \"" + myFieldInfo.ConstantValue + "\"";
}
else
{
constValue = " = " + myFieldInfo.ConstantValue;
}
}
string syntax = String.Format("{0} {1} {2}{3}", myFieldInfo.AttributesString,
ProcessType(myFieldInfo.TypeFullName),
myFieldInfo.DisplayableName,
constValue);
ProcessFieldOrEvent("F_", myFieldInfo.Name, "Field", declaringType, dirName,
myFieldInfo.Summary, myFieldInfo.Remarks, syntax, myFieldInfo.Example);
}
private void CreatePropertiesOverloadsIndex(MyPropertiesOverloadsInfo myPropertiessOverloadsInfo, MyClassInfo declaringType, string dirName)
{
Debug.Assert(myPropertiessOverloadsInfo.Count > 1, "Impossible! We don't create overloads index when there are no overloads.");
string prefix = "PO_";
string fileName = Utils.CombineMultiplePaths(dirName, prefix + GetMyPropertyInfoVisibilitModifiersCodeString(myPropertiessOverloadsInfo[0]) + "_" + myPropertiessOverloadsInfo.Name + "_" + myPropertiessOverloadsInfo.Name.GetHashCode() + ".html");
FileStream fs = new FileStream(GetAliasName(fileName), FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
string pageTitle = String.Format("{0}.{1} Property", Utils.HTMLEncode(declaringType.DisplayableName), Utils.HTMLEncode(myPropertiessOverloadsInfo[0].DisplayableName));
string[] sectionsNamesAndIndices = { "Overload List:0" };
int sectionIndex = 0;
WriteIndexHeader(sw, pageTitle, sectionsNamesAndIndices);
WriteIndexSummary(sw, myPropertiessOverloadsInfo.SummaryWithoutPrefix);
WriteIndexItemLocation(sw, declaringType.DisplayableName, declaringType.Namespace, declaringType.AssemblyName,
ResolveNamespaceMemberLink(declaringType.AssemblyName, declaringType.Namespace, declaringType.Name),
ResolveNamespaceLink(declaringType.AssemblyName, declaringType.Namespace),
ResolveAssemblyLink(declaringType.AssemblyName));
WriteIndexSectionBegin(sw,
sectionsNamesAndIndices[sectionIndex].Substring(0, sectionsNamesAndIndices[sectionIndex].LastIndexOf(':')),
sectionIndex);
WriteIndexMembersTableBegin(sw,
DEFAULT_MEMBERS_COLUMNS_NAMES,
TYPE_MEMBERS_COLUMNS_WIDTHS);
int index = -1;
foreach (MyPropertyInfo myPropertyInfo in myPropertiessOverloadsInfo)
{
IconsTypes iconsTypes = GetIconsTypes(myPropertyInfo, 0, 0);
index++;
string link = ResolvePropertyLink(myPropertyInfo, declaringType, index);
string displayableName = Utils.HTMLEncode(myPropertyInfo.DisplayableName);
string name = Utils.HTMLEncode(declaringType.DisplayableName + "." + displayableName + " (");
if (myPropertyInfo.Parameters.Count > 0)
{
bool first = true;
foreach (string parameterName in myPropertyInfo.ParametersNames)
{
MyParameterInfo myParameterInfo = myPropertyInfo.Parameters[parameterName];
string processedType = ProcessType(myParameterInfo.TypeFullName);
if (!first)
{
name += ", ";
}
name += processedType;
first = false;
}
}
WriteIndexMembersTableRow(sw,
name + ")",
link,
myPropertyInfo.Summary,
Icons.GetFileNames(iconsTypes),
Icons.GetAltLabels(iconsTypes));
}
WriteIndexMembersTableEnd(sw);
WriteIndexSectionEnd(sw);
WriteIndexFooter(sw);
sw.Close();
fs.Close();
}
private string CreateNamespaceMemberSyntaxTable(MyClassInfo namespaceMember, string name, string metaName)
{
StringBuilder sb = new StringBuilder();
sb.Append("<table style=\"width: 100%;\" class=\"InsideCodeBlock\">\n");
sb.Append("<col width=\"0%\" />\n");
sb.Append("<col width=\"100%\" />\n");
string baseTypeName = null;
if (namespaceMember is MyEnumerationInfo)
{
baseTypeName = ((MyEnumerationInfo)namespaceMember).UnderlyingTypeFullName;
}
else if (!(namespaceMember is MyStructureInfo) && !(namespaceMember is MyDelegateInfo) && !(namespaceMember is MyInterfaceInfo))
{
if (namespaceMember.BaseTypeName != null && namespaceMember.BaseTypeName.ToLower() != "system.object")
{
baseTypeName = namespaceMember.BaseTypeName;
}
}
bool hasBaseTypeOrInterfaces = baseTypeName != null || namespaceMember.ImplementedInterfacesNames.Count > 0;
sb.Append("<tr>\n");
sb.Append(String.Format("<td class=\"NoWrapTop\">{0} {1} {2} {3}</td>\n", namespaceMember.AttributesString,
metaName,
name,
hasBaseTypeOrInterfaces ? ": " : ""));
if (hasBaseTypeOrInterfaces)
{
sb.Append("<td>\n");
if (baseTypeName != null)
{
sb.Append(ProcessType(baseTypeName));
}
if (!(namespaceMember is MyEnumerationInfo))
{
string implementedInterfaces = GetImlpementedInterfacesString(namespaceMember.ImplementedInterfacesNames);
if (baseTypeName != null)
{
if (implementedInterfaces != "")
{
sb.Append(',');
}
sb.Append("<br />");
}
sb.Append(implementedInterfaces);
}
sb.Append("\n</td>\n");
}
else
{
sb.Append("<td> </td>\n");
}
sb.Append("</tr>\n");
sb.Append("</table>\n");
if (namespaceMember.GenericParametersCount > 0 && namespaceMember.ContainsGenericParameterWithConstraints)
{
WriteGenericParametersConstraints(namespaceMember.GenericParameters, sb);
}
return sb.ToString();
}
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[] ObtainListOfMembersSectionsNames(MyClassInfo myClassInfo)
{
if (myClassInfo is MyEnumerationInfo || myClassInfo is MyDelegateInfo)
{
Debug.Assert(false, String.Format("Impossible! We don't want to create member's index of type '{0}'.", myClassInfo.GetType()));
return null;
}
List<string> result = new List<string>();
int classMembersGroupTypeIndex = 0;
int sectionIndex = 0;
while (Enum.IsDefined(typeof(ClassMembersGroups), classMembersGroupTypeIndex))
{
ClassMembersGroups classMembersGroupType = (ClassMembersGroups)classMembersGroupTypeIndex;
if (myClassInfo.GetMembersCount(classMembersGroupType) > 0)
{
string sectionName = MyClassInfo.ClassMembersGroupsToString(classMembersGroupType);
int tmpSectionIndex = sectionIndex;
tmpSectionIndex++;
if (myClassInfo.HasProtectedInternalGroupOfTheSameType(classMembersGroupType))
{
sectionName += String.Format(" ${{SectionReference:{0}:{1}}}", tmpSectionIndex, "Protected Internal");
}
tmpSectionIndex++;
if (myClassInfo.HasProtectedGroupOfTheSameType(classMembersGroupType))
{
sectionName += String.Format(" ${{SectionReference:{0}:{1}}}", tmpSectionIndex, "Protected");
}
tmpSectionIndex++;
if (myClassInfo.HasInternalGroupOfTheSameType(classMembersGroupType))
{
sectionName += String.Format(" ${{SectionReference:{0}:{1}}}", tmpSectionIndex, "Internal");
}
tmpSectionIndex++;
if (myClassInfo.HasPrivateGroupOfTheSameType(classMembersGroupType))
{
sectionName += String.Format(" ${{SectionReference:{0}:{1}}}", tmpSectionIndex, "Private");
}
result.Add(sectionName);
}
classMembersGroupTypeIndex++;
sectionIndex++;
}
return result.ToArray();
}
private void AddGenericNameMappingIfNeeded(MyClassInfo myClassInfo, NamespaceMembersGroups namespaceMembersGroupType)
{
if (!myClassInfo.Name.Contains("<"))
{
return;
}
Dictionary<string, string> genericNamesMappingsForGroup = GetGenericNamesMappingsForGroup(namespaceMembersGroupType);
string xmlName = Utils.ConvertNameToXmlDocForm(myClassInfo.Name);
genericNamesMappingsForGroup[xmlName] = myClassInfo.Name;
}
private void ProcessNamespaceMemberMembers(MyClassInfo namespaceMember, NamespaceMembersGroups namespaceMembersGroupType)
{
switch (namespaceMembersGroupType)
{
case NamespaceMembersGroups.PublicClasses: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.PublicStructures: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.PublicInterfaces: { ProcessInterfaceMembers((MyInterfaceInfo)namespaceMember); break; }
case NamespaceMembersGroups.PublicDelegates: { break; }
case NamespaceMembersGroups.PublicEnumerations: { ProcessEnumerationMembers((MyEnumerationInfo)namespaceMember); break; }
case NamespaceMembersGroups.ProtectedInternalClasses: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.ProtectedInternalStructures: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.ProtectedInternalInterfaces: { ProcessInterfaceMembers((MyInterfaceInfo)namespaceMember); break; }
case NamespaceMembersGroups.ProtectedInternalDelegates: { break; }
case NamespaceMembersGroups.ProtectedInternalEnumerations: { ProcessEnumerationMembers((MyEnumerationInfo)namespaceMember); break; }
case NamespaceMembersGroups.ProtectedClasses: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.ProtectedStructures: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.ProtectedInterfaces: { ProcessInterfaceMembers((MyInterfaceInfo)namespaceMember); break; }
case NamespaceMembersGroups.ProtectedDelegates: { break; }
case NamespaceMembersGroups.ProtectedEnumerations: { ProcessEnumerationMembers((MyEnumerationInfo)namespaceMember); break; }
case NamespaceMembersGroups.InternalClasses: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.InternalStructures: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.InternalInterfaces: { ProcessInterfaceMembers((MyInterfaceInfo)namespaceMember); break; }
case NamespaceMembersGroups.InternalDelegates: { break; }
case NamespaceMembersGroups.InternalEnumerations: { ProcessEnumerationMembers((MyEnumerationInfo)namespaceMember); break; }
case NamespaceMembersGroups.PrivateClasses: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.PrivateStructures: { ProcessClassOrStructureMembers(namespaceMember); break; }
case NamespaceMembersGroups.PrivateInterfaces: { ProcessInterfaceMembers((MyInterfaceInfo)namespaceMember); break; }
case NamespaceMembersGroups.PrivateDelegates: { break; }
case NamespaceMembersGroups.PrivateEnumerations: { ProcessEnumerationMembers((MyEnumerationInfo)namespaceMember); break; }
default: { Debug.Assert(false, "Impossible! Couldn't recognize type of namespace member."); break; }
}
}
public MyNestedTypeInfo GetNestedTypeMember(MyClassInfo physicalClass)
{
int indexOfLastPlus = physicalClass.Name.LastIndexOf('/');
Debug.Assert(indexOfLastPlus != -1 && indexOfLastPlus + 1 < physicalClass.Name.Length, "Impossible! Trying to get nested type for a type which is not nested.");
if (indexOfLastPlus == -1)
{
return null;
}
string memberName = physicalClass.Name.Substring(indexOfLastPlus + 1);
MyNestedTypeInfo nestedType;
if (physicalClass.IsPublic)
{
nestedType = GetMember(ClassMembersGroups.PublicClasses, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.PublicStructures, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.PublicInterfaces, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.PublicDelegates, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.PublicEnumerations, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
}
else if (physicalClass.IsProtectedInternal)
{
nestedType = GetMember(ClassMembersGroups.ProtectedInternalClasses, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.ProtectedInternalStructures, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.ProtectedInternalInterfaces, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.ProtectedInternalDelegates, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.ProtectedInternalEnumerations, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
}
else if (physicalClass.IsProtected)
{
nestedType = GetMember(ClassMembersGroups.ProtectedClasses, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.ProtectedStructures, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.ProtectedInterfaces, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.ProtectedDelegates, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.ProtectedEnumerations, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
}
else if (physicalClass.IsInternal)
{
nestedType = GetMember(ClassMembersGroups.InternalClasses, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.InternalStructures, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.InternalInterfaces, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.InternalDelegates, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.InternalEnumerations, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
}
else if (physicalClass.IsPrivate)
{
nestedType = GetMember(ClassMembersGroups.PrivateClasses, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.PrivateStructures, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.PrivateInterfaces, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.PrivateDelegates, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
nestedType = GetMember(ClassMembersGroups.PrivateEnumerations, memberName) as MyNestedTypeInfo;
if (nestedType != null) return nestedType;
}
else
{
Debug.Assert(false, "Impossible! Unsupported type visibility.");
}
return null;
}
private static bool ReturnTypesMatch(string csTypeFullName, string xmlTypeFullName, MyClassInfo memberDeclaringType, List<MyGenericParameterInfo> memberGenericParameters)
{
string almostXmlRepresentation = MyParameterInfo.GetXMLCompatibleRepresentation(csTypeFullName, false, false);
string almostCSRepresentation = GetAlmostCSRepresentation(xmlTypeFullName, memberDeclaringType, memberGenericParameters);
return almostXmlRepresentation == almostCSRepresentation;
}
private static string GetAlmostCSRepresentation(string xmlParamType, MyClassInfo memberDeclaringType, List<MyGenericParameterInfo> memberGenericParameters)
{
string result;
if (xmlParamType.Contains("`"))
{
// resolve generic parameters
result = new MatchEvaluatorWrapper(memberDeclaringType, memberGenericParameters).Process(xmlParamType);
}
else
{
result = xmlParamType;
}
return result.Replace('{', '<').Replace('}', '>');
}
public MatchEvaluatorWrapper(MyClassInfo memberDeclaringType, List<MyGenericParameterInfo> memberGenericParameters)
{
_memberDeclaringType = memberDeclaringType;
_memberGenericParameters = memberGenericParameters;
}
private static MyGenericParameterInfo FindGenericParameter(MyClassInfo myClassInfo, string typeParamName)
{
return myClassInfo.FindGenericParameter(typeParamName);
}
private void ProcessFieldOrEvent(string prefix, string name, string metaName, MyClassInfo declaringType, string dirName, string summary, string remarks, string syntax, string example)
{
string fileName = Utils.CombineMultiplePaths(dirName, prefix + name + "_" + name.GetHashCode() + ".html");
string filename = Utils.CombineMultiplePaths(outputDirectory, CONTENTS_DIRECTORY, GetAliasName(fileName));
FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
string pageTitle = String.Format("{0}.{1} {2}", Utils.HTMLEncode(declaringType.DisplayableName), name, metaName);
string[] sectionsNamesAndIndices;
if (remarks == null || remarks == "")
{
if (example == null || example == "")
{
sectionsNamesAndIndices = new string[] { "Syntax:0" };
}
else
{
sectionsNamesAndIndices = new string[] { "Syntax:0", "Example:1" };
}
}
else
{
if (example == null || example == "")
{
sectionsNamesAndIndices = new string[] { "Syntax:0", "Remarks:1" };
}
else
{
sectionsNamesAndIndices = new string[] { "Syntax:0", "Remarks:1", "Example:2" };
}
}
int sectionIndex = 0;
WriteIndexHeader(sw, pageTitle, sectionsNamesAndIndices);
WriteIndexSummary(sw, summary);
WriteIndexItemLocation(sw, declaringType.DisplayableName, declaringType.Namespace, declaringType.AssemblyName,
ResolveNamespaceMemberLink(declaringType.AssemblyName, declaringType.Namespace, declaringType.Name),
ResolveNamespaceLink(declaringType.AssemblyName, declaringType.Namespace),
ResolveAssemblyLink(declaringType.AssemblyName));
WriteIndexSectionBegin(sw,
sectionsNamesAndIndices[sectionIndex].Substring(0, sectionsNamesAndIndices[sectionIndex].LastIndexOf(':')),
sectionIndex);
WriteIndexCodeBlockTable(sw, DEFAULT_LANGUAGE, syntax);
WriteIndexSectionEnd(sw);
sectionIndex++;
if (remarks != "")
{
WriteIndexSectionBegin(sw,
sectionsNamesAndIndices[sectionIndex].Substring(0, sectionsNamesAndIndices[sectionIndex].LastIndexOf(':')),
sectionIndex);
WriteIndexRemarks(sw, remarks);
WriteIndexSectionEnd(sw);
sectionIndex++;
}
if (example != "")
{
string sectionName = sectionsNamesAndIndices[sectionIndex].Substring(0, sectionsNamesAndIndices[sectionIndex].LastIndexOf(':'));
Debug.Assert(sectionName == "Example", "There should be 'Example' section now.");
WriteIndexSectionBegin(sw, sectionName, sectionIndex);
WriteIndexExample(sw, example);
WriteIndexSectionEnd(sw);
sectionIndex++;
}
WriteIndexFooter(sw);
sw.Close();
fs.Close();
}
private void ProcessClassOrStructureMembers(MyClassInfo myClassOrStructureInfo)
{
string namespaceDirName = GetNamespaceDirName(myClassOrStructureInfo.Namespace);
string dirName = Utils.CombineMultiplePaths(myClassOrStructureInfo.AssemblyName + "_" + myClassOrStructureInfo.AssemblyName.GetHashCode(),
namespaceDirName,
CLASS_MEMBERS_DIRECTORY,
myClassOrStructureInfo.Name + "_" + myClassOrStructureInfo.Name.GetHashCode());
List<MetaClass> fields = myClassOrStructureInfo.GetMembers(ClassMembersGroups.PublicFields);
fields.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedFields));
fields.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedInternalFields));
if ((options & DocumentationGenerationOptions.IncludeInternalMembers) != 0)
{
fields.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.InternalFields));
}
if ((options & DocumentationGenerationOptions.IncludePrivateMembers) != 0)
{
fields.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.PrivateFields));
}
foreach (MyFieldInfo myFieldInfo in fields)
{
ProcessField(myFieldInfo, myClassOrStructureInfo, dirName);
}
List<MetaClass> constructorsOverloads = myClassOrStructureInfo.GetMembers(ClassMembersGroups.PublicConstructors);
constructorsOverloads.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedConstructors));
constructorsOverloads.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedInternalConstructors));
if ((options & DocumentationGenerationOptions.IncludeInternalMembers) != 0)
{
constructorsOverloads.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.InternalConstructors));
}
if ((options & DocumentationGenerationOptions.IncludePrivateMembers) != 0)
{
constructorsOverloads.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.PrivateConstructors));
}
foreach (MyInvokableMembersOverloadsInfo myInvokableMembersOverloadsInfo in constructorsOverloads)
{
ProcessInvokableMembersOverloads(myInvokableMembersOverloadsInfo, myClassOrStructureInfo, dirName);
}
List<MetaClass> methodsOverloads = myClassOrStructureInfo.GetMembers(ClassMembersGroups.PublicMethodsOverloads);
methodsOverloads.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedMethodsOverloads));
methodsOverloads.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedInternalMethodsOverloads));
if ((options & DocumentationGenerationOptions.IncludeInternalMembers) != 0)
{
methodsOverloads.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.InternalMethodsOverloads));
}
if ((options & DocumentationGenerationOptions.IncludePrivateMembers) != 0)
{
methodsOverloads.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.PrivateMethodsOverloads));
}
foreach (MyInvokableMembersOverloadsInfo myInvokableMembersOverloadsInfo in methodsOverloads)
{
ProcessInvokableMembersOverloads(myInvokableMembersOverloadsInfo, myClassOrStructureInfo, dirName);
}
List<MetaClass> properties = myClassOrStructureInfo.GetMembers(ClassMembersGroups.PublicPropertiesOverloads);
properties.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedPropertiesOverloads));
properties.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedInternalPropertiesOverloads));
if ((options & DocumentationGenerationOptions.IncludeInternalMembers) != 0)
{
properties.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.InternalPropertiesOverloads));
}
if ((options & DocumentationGenerationOptions.IncludePrivateMembers) != 0)
{
properties.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.PrivatePropertiesOverloads));
}
foreach (MyPropertiesOverloadsInfo myPropertiesOverloads in properties)
{
ProcessPropertiesOverloads(myPropertiesOverloads, myClassOrStructureInfo, dirName);
}
List<MetaClass> events = myClassOrStructureInfo.GetMembers(ClassMembersGroups.PublicEvents);
events.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedEvents));
events.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.ProtectedInternalEvents));
if ((options & DocumentationGenerationOptions.IncludeInternalMembers) != 0)
{
events.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.InternalEvents));
}
if ((options & DocumentationGenerationOptions.IncludePrivateMembers) != 0)
{
events.AddRange(myClassOrStructureInfo.GetMembers(ClassMembersGroups.PrivateEvents));
}
foreach (MyEventInfo myEventInfo in events)
{
ProcessEvent(myEventInfo, myClassOrStructureInfo, dirName);
}
}
private string ResolveInvokableMemberLink(MyInvokableMemberInfo myInvokableMemberInfo, MyClassInfo declaringType, int indexInOverloadsList)
{
string prefix;
if (myInvokableMemberInfo is MyConstructorInfo)
{
prefix = "C_" + GetMyInvokableMemberVisibilitModifiersCodeString(myInvokableMemberInfo) + "_";
}
else
{
Debug.Assert(myInvokableMemberInfo is MyMethodInfo, "Impossible!");
prefix = "M_" + GetMyInvokableMemberVisibilitModifiersCodeString(myInvokableMemberInfo) + "_";
}
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 + myInvokableMemberInfo.Name + "_" + indexInOverloadsList + "_" + myInvokableMemberInfo.Name.GetHashCode() + ".html",
true, true);
}
private void ProcessPropertiesOverloads(MyPropertiesOverloadsInfo myPropertiesOverloadsInfo, MyClassInfo declaringType, string dirName)
{
if (myPropertiesOverloadsInfo.Count > 1)
{
CreatePropertiesOverloadsIndex(myPropertiesOverloadsInfo, declaringType, dirName);
}
string prefix = "P_";
int index = -1;
foreach (MyPropertyInfo myPropertyInfo in myPropertiesOverloadsInfo)
{
index++;
string fileName = Utils.CombineMultiplePaths(dirName, prefix + GetMyPropertyInfoVisibilitModifiersCodeString(myPropertyInfo) + "_" + myPropertyInfo.Name + "_" + index + "_" + myPropertyInfo.Name.GetHashCode() + ".html");
string filename = Utils.CombineMultiplePaths(outputDirectory, CONTENTS_DIRECTORY, GetAliasName(fileName));
FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
string paramsString = "(";
bool first = true;
foreach (string paramName in myPropertyInfo.ParametersNames)
{
MyParameterInfo myParameterInfo = myPropertyInfo.Parameters[paramName];
if (!first)
{
paramsString += ", ";
}
paramsString += ProcessType(myParameterInfo.TypeFullName);
first = false;
}
paramsString += ")";
if (paramsString == "()") { paramsString = ""; }
string pageTitle = Utils.HTMLEncode(declaringType.DisplayableName) + "." + Utils.HTMLEncode(myPropertyInfo.DisplayableName) + " Property " + paramsString;
List<string> sectionsNames = new List<string>();
sectionsNames.Add("Syntax");
if (myPropertyInfo.ExceptionsDescrs.Count > 0)
{
sectionsNames.Add("Exceptions");
}
if (myPropertyInfo.Remarks != "")
{
sectionsNames.Add("Remarks");
}
if (myPropertyInfo.Example != "")
{
sectionsNames.Add("Example");
}
string[] sectionsNamesAndIndices = new string[sectionsNames.Count];
for (int i = 0; i < sectionsNamesAndIndices.Length; i++)
{
sectionsNamesAndIndices[i] = sectionsNames[i] + ":" + i;
}
WriteIndexHeader(sw, pageTitle, sectionsNamesAndIndices);
WriteIndexSummary(sw, myPropertyInfo.Summary);
WriteIndexItemLocation(sw, declaringType.DisplayableName, declaringType.Namespace, declaringType.AssemblyName,
ResolveNamespaceMemberLink(declaringType.AssemblyName, declaringType.Namespace, declaringType.Name),
ResolveNamespaceLink(declaringType.AssemblyName, declaringType.Namespace),
ResolveAssemblyLink(declaringType.AssemblyName));
int sectionIndex = 0;
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
string syntax = CreatePropertySyntaxString(myPropertyInfo);
WriteIndexCodeBlockTable(sw, DEFAULT_LANGUAGE, syntax);
WriteParametersAndReturnValueDescriptions(sw, myPropertyInfo.ParametersNames, myPropertyInfo.Parameters,
((MyPropertyInfo)myPropertyInfo).TypeFullName,
((MyPropertyInfo)myPropertyInfo).ReturnValueSummary,
true);
WriteIndexSectionEnd(sw);
sectionIndex++;
if (myPropertyInfo.ExceptionsDescrs.Count > 0)
{
Debug.Assert(sectionsNames[sectionIndex] == "Exceptions", "Exceptions section was expected.");
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
WriteIndexExceptionsTable(sw, myPropertyInfo.ExceptionsDescrs);
WriteIndexSectionEnd(sw);
sectionIndex++;
}
if (myPropertyInfo.Remarks != "")
{
Debug.Assert(sectionsNames[sectionIndex] == "Remarks", "Remarks section was expected.");
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
WriteIndexRemarks(sw, myPropertyInfo.Remarks);
WriteIndexSectionEnd(sw);
sectionIndex++;
}
if (myPropertyInfo.Example != "")
{
Debug.Assert(sectionsNames[sectionIndex] == "Example", "There should be 'Example' section now.");
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
WriteIndexExample(sw, myPropertyInfo.Example);
WriteIndexSectionEnd(sw);
sectionIndex++;
}
WriteIndexFooter(sw);
sw.Close();
fs.Close();
}
}
private string[] ObtainListOfMembersSectionsShortcutsNamesAndIndices(MyClassInfo myClassInfo)
{
if (myClassInfo is MyEnumerationInfo || myClassInfo is MyDelegateInfo)
{
Debug.Assert(false, String.Format("Impossible! We don't want to create member's index of type '{0}'.", myClassInfo.GetType()));
return null;
}
List<string> result = new List<string>();
int classMembersGroupTypeIndex = 0;
int sectionIndex = 0;
while (Enum.IsDefined(typeof(ClassMembersGroups), classMembersGroupTypeIndex))
{
ClassMembersGroups classMembersGroupType = (ClassMembersGroups)classMembersGroupTypeIndex;
if (myClassInfo.GetMembersCount(classMembersGroupType) > 0)
{
if (MyClassInfo.IsMembersGroupPublic(classMembersGroupType))
{
result.Add(MyClassInfo.GetBaseGroupName(classMembersGroupType) + ":" + sectionIndex);
}
}
classMembersGroupTypeIndex++;
sectionIndex++;
}
return result.ToArray();
}
private string CreateNamespaceMemberSyntaxString(MyClassInfo namespaceMember)
{
string name = Utils.HTMLEncode(Utils.GetUnqualifiedName(namespaceMember.DisplayableName));
string metaName = "class";
if (namespaceMember is MyStructureInfo) { metaName = "struct"; }
else if (namespaceMember is MyInterfaceInfo) { metaName = "interface"; }
else if (namespaceMember is MyDelegateInfo)
{
MyDelegateInfo myDelegateInfo = (MyDelegateInfo)namespaceMember;
List<MyGenericParameterInfo> genericParameters = myDelegateInfo.GenericParametersCount == 0 || !myDelegateInfo.ContainsGenericParameterWithConstraints ? null : myDelegateInfo.GenericParameters;
return CreateInvokableMemberOrDelegateSyntaxString(myDelegateInfo.AttributesString,
" " + ProcessType(myDelegateInfo.ReturnTypeFullName),
name,
myDelegateInfo.ParametersNames,
myDelegateInfo.Parameters,
genericParameters);
}
else if (namespaceMember is MyEnumerationInfo) { metaName = "enum"; }
return CreateNamespaceMemberSyntaxTable(namespaceMember, name, metaName);
}
private string GetDeclaringTypeNameOfANestedType(MyClassInfo myClassInfo)
{
int indexOfLastPlus = myClassInfo.Name.LastIndexOf('/');
if (indexOfLastPlus == -1)
{
return null;
}
return myClassInfo.Name.Substring(0, indexOfLastPlus);
}
private static bool SignaturesMatch(List<String> memberParametersNames, Dictionary<string, MyParameterInfo> memberParameters, List<string> xmlParamsTypes, MyClassInfo memberDeclaringType, List<MyGenericParameterInfo> memberGenericParameters)
{
if (memberParametersNames.Count != xmlParamsTypes.Count)
{
return false;
}
bool signaturesMatch = true;
int i = 0;
foreach (string paramName in memberParametersNames)
{
MyParameterInfo myParameterInfo = memberParameters[paramName];
string almostXmlRepresentation = myParameterInfo.GetXMLCompatibleRepresentation();
string almostCSRepresentation = GetAlmostCSRepresentation(xmlParamsTypes[i], memberDeclaringType, memberGenericParameters);
if (almostXmlRepresentation != almostCSRepresentation)
{
signaturesMatch = false;
break;
}
i++;
}
return signaturesMatch;
}