public IEnumerable <MetaClass> GetEnumerator()
{
List <MetaClass> sortedMembers = new List <MetaClass>();
int namespaceMembersGroupIndex = 0;
while (Enum.IsDefined(typeof(NamespaceMembersGroups), namespaceMembersGroupIndex))
{
NamespaceMembersGroups namespaceMembersGroup = (NamespaceMembersGroups)namespaceMembersGroupIndex;
if (GetMembersCount(namespaceMembersGroup) > 0)
{
Dictionary <string, MetaClass> membersGroup = GetMembers(namespaceMembersGroup);
foreach (MetaClass member in membersGroup.Values)
{
sortedMembers.Add(member);
}
}
namespaceMembersGroupIndex++;
}
sortedMembers.Sort(new Comparison <MetaClass>(MembersComparison));
return(sortedMembers);
}
public Dictionary <string, MetaClass> GetMembers(NamespaceMembersGroups namespaceMembersGroupType)
{
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
return(null);
}
return(membersGroups[namespaceMembersGroupType]);
}
public int GetMembersCount(NamespaceMembersGroups namespaceMembersGroupType)
{
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
return(0);
}
return(membersGroups[namespaceMembersGroupType].Count);
}
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 Dictionary <string, MetaClass> GetMembersGroup(NamespaceMembersGroups namespaceMembersGroupType)
{
Dictionary <string, MetaClass> membersGroup;
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
membersGroup = new Dictionary <string, MetaClass>();
membersGroups[namespaceMembersGroupType] = membersGroup;
}
else
{
membersGroup = membersGroups[namespaceMembersGroupType];
}
return(membersGroup);
}
public bool HasPrivateGroupOfTheSameType(NamespaceMembersGroups membersGroupType)
{
switch (membersGroupType)
{
case NamespaceMembersGroups.PublicClasses: { return(GetMembersCount(NamespaceMembersGroups.PrivateClasses) > 0); }
case NamespaceMembersGroups.PublicStructures: { return(GetMembersCount(NamespaceMembersGroups.PrivateStructures) > 0); }
case NamespaceMembersGroups.PublicInterfaces: { return(GetMembersCount(NamespaceMembersGroups.PrivateInterfaces) > 0); }
case NamespaceMembersGroups.PublicDelegates: { return(GetMembersCount(NamespaceMembersGroups.PrivateDelegates) > 0); }
case NamespaceMembersGroups.PublicEnumerations: { return(GetMembersCount(NamespaceMembersGroups.PrivateEnumerations) > 0); }
default: return(false);
}
}
public static bool IsMembersGroupTypePublic(NamespaceMembersGroups membersGroupType)
{
switch (membersGroupType)
{
case NamespaceMembersGroups.PublicClasses: { return(true); }
case NamespaceMembersGroups.PublicStructures: { return(true); }
case NamespaceMembersGroups.PublicInterfaces: { return(true); }
case NamespaceMembersGroups.PublicDelegates: { return(true); }
case NamespaceMembersGroups.PublicEnumerations: { return(true); }
default: { return(false); }
}
}
internal IEnumerator <ISummarisableMember> GetEnumerator(NamespaceMembersGroups namespaceMembersGroupType)
{
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
Debug.Assert(false, "Impossible! Couldn't recognize members group ('" + namespaceMembersGroupType + "').");
yield break;
}
Dictionary <string, MetaClass> membersGroup = membersGroups[namespaceMembersGroupType];
List <string> sortedKeys = new List <string>();
sortedKeys.AddRange(membersGroup.Keys);
sortedKeys.Sort();
foreach (string key in sortedKeys)
{
yield return((ISummarisableMember)membersGroup[key]);
}
}
private Dictionary <string, string> GetGenericNamesMappingsForGroup(NamespaceMembersGroups namespaceMembersGroupType)
{
if (genericNamesMappings == null)
{
genericNamesMappings = new Dictionary <NamespaceMembersGroups, Dictionary <string, string> >();
}
Dictionary <string, string> genericNamesMappingsForGroup;
if (!genericNamesMappings.ContainsKey(namespaceMembersGroupType))
{
genericNamesMappingsForGroup = new Dictionary <string, string>();
genericNamesMappings[namespaceMembersGroupType] = genericNamesMappingsForGroup;
}
else
{
genericNamesMappingsForGroup = genericNamesMappings[namespaceMembersGroupType];
}
return(genericNamesMappingsForGroup);
}
public MyClassInfo FindMember(NamespaceMembersGroups namespaceMembersGroupType, string memberName)
{
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
return(null);
}
Dictionary <string, MetaClass> membersGroup = membersGroups[namespaceMembersGroupType];
MetaClass member = null;
if (!membersGroup.ContainsKey(memberName))
{
// try indirect search (for generic types)
if (genericNamesMappings == null || !genericNamesMappings.ContainsKey(namespaceMembersGroupType))
{
return(null);
}
Dictionary <string, string> genericNamesMappingsForGroup = genericNamesMappings[namespaceMembersGroupType];
if (!genericNamesMappingsForGroup.ContainsKey(memberName))
{
return(null);
}
memberName = genericNamesMappingsForGroup[memberName];
if (!membersGroup.ContainsKey(memberName))
{
return(null);
}
}
member = membersGroup[memberName];
Debug.Assert(member is MyClassInfo, "Impossible! All namespace member inherit from MyClassInfo.");
return((MyClassInfo)member);
}
private Dictionary<string, string> GetGenericNamesMappingsForGroup(NamespaceMembersGroups namespaceMembersGroupType)
{
if (genericNamesMappings == null)
{
genericNamesMappings = new Dictionary<NamespaceMembersGroups, Dictionary<string, string>>();
}
Dictionary<string, string> genericNamesMappingsForGroup;
if (!genericNamesMappings.ContainsKey(namespaceMembersGroupType))
{
genericNamesMappingsForGroup = new Dictionary<string, string>();
genericNamesMappings[namespaceMembersGroupType] = genericNamesMappingsForGroup;
}
else
{
genericNamesMappingsForGroup = genericNamesMappings[namespaceMembersGroupType];
}
return genericNamesMappingsForGroup;
}
private Dictionary<string, MetaClass> GetMembersGroup(NamespaceMembersGroups namespaceMembersGroupType)
{
Dictionary<string, MetaClass> membersGroup;
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
membersGroup = new Dictionary<string, MetaClass>();
membersGroups[namespaceMembersGroupType] = membersGroup;
}
else
{
membersGroup = membersGroups[namespaceMembersGroupType];
}
return membersGroup;
}
public bool HasPrivateGroupOfTheSameType(NamespaceMembersGroups membersGroupType)
{
switch (membersGroupType)
{
case NamespaceMembersGroups.PublicClasses: { return GetMembersCount(NamespaceMembersGroups.PrivateClasses) > 0; }
case NamespaceMembersGroups.PublicStructures: { return GetMembersCount(NamespaceMembersGroups.PrivateStructures) > 0; }
case NamespaceMembersGroups.PublicInterfaces: { return GetMembersCount(NamespaceMembersGroups.PrivateInterfaces) > 0; }
case NamespaceMembersGroups.PublicDelegates: { return GetMembersCount(NamespaceMembersGroups.PrivateDelegates) > 0; }
case NamespaceMembersGroups.PublicEnumerations: { return GetMembersCount(NamespaceMembersGroups.PrivateEnumerations) > 0; }
default: return false;
}
}
public static bool IsMembersGroupTypePublic(NamespaceMembersGroups membersGroupType)
{
switch (membersGroupType)
{
case NamespaceMembersGroups.PublicClasses: { return true; }
case NamespaceMembersGroups.PublicStructures: { return true; }
case NamespaceMembersGroups.PublicInterfaces: { return true; }
case NamespaceMembersGroups.PublicDelegates: { return true; }
case NamespaceMembersGroups.PublicEnumerations: { return true; }
default: { return false; }
}
}
private void CreateNamespaceMemberMembersIndex(MetaClass namespaceMember, NamespaceMembersGroups namespaceMembersGroupType)
{
if (namespaceMembersGroupType == NamespaceMembersGroups.PublicEnumerations || namespaceMembersGroupType == NamespaceMembersGroups.PublicDelegates
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInternalEnumerations || namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInternalDelegates
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedEnumerations || namespaceMembersGroupType == NamespaceMembersGroups.ProtectedDelegates
|| namespaceMembersGroupType == NamespaceMembersGroups.InternalEnumerations || namespaceMembersGroupType == NamespaceMembersGroups.InternalDelegates
|| namespaceMembersGroupType == NamespaceMembersGroups.PrivateEnumerations || namespaceMembersGroupType == NamespaceMembersGroups.PrivateDelegates)
{
Debug.Assert(false, String.Format("Impossible! We don't want to create member's index of type '{0}'.", namespaceMember.GetType()));
return;
}
MyClassInfo myClassInfo = (MyClassInfo)namespaceMember;
string namespaceDirName = GetNamespaceDirName(myClassInfo.Namespace);
string indexFileName = Utils.CombineMultiplePaths(myClassInfo.AssemblyName + "_" + myClassInfo.AssemblyName.GetHashCode(),
namespaceDirName,
"MS_" + myClassInfo.Name + "_" + myClassInfo.Name.GetHashCode() + ".html");
string filename = Utils.CombineMultiplePaths(outputDirectory, CONTENTS_DIRECTORY, GetAliasName(indexFileName));
FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
string memberTypeName = "";
switch (namespaceMembersGroupType)
{
case NamespaceMembersGroups.PublicClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.PublicInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.PublicStructures: memberTypeName = "Structure"; break;
case NamespaceMembersGroups.ProtectedInternalClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.ProtectedInternalInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.ProtectedInternalStructures: memberTypeName = "Structure"; break;
case NamespaceMembersGroups.ProtectedClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.ProtectedInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.ProtectedStructures: memberTypeName = "Structure"; break;
case NamespaceMembersGroups.InternalClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.InternalInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.InternalStructures: memberTypeName = "Structure"; break;
case NamespaceMembersGroups.PrivateClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.PrivateInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.PrivateStructures: memberTypeName = "Structure"; break;
default: Debug.Assert(false, "Impossible! Couldn't obtain member's type name."); break;
}
string pageTitle = String.Format("{0} {1} Members", Utils.HTMLEncode(myClassInfo.Name.Replace('/', '.')), memberTypeName);
string[] sectionsShortcutsNamesAndIndices = ObtainListOfMembersSectionsShortcutsNamesAndIndices(myClassInfo);
string[] sectionsNames = ObtainListOfMembersSectionsNames(myClassInfo);
WriteIndexHeader(sw, pageTitle, sectionsShortcutsNamesAndIndices);
WriteIndexSummary(sw, myClassInfo.Summary);
WriteIndexItemLocation(sw,
myClassInfo.DisplayableName,
myClassInfo.Namespace,
myClassInfo.AssemblyName,
ResolveNamespaceMemberLink(myClassInfo.AssemblyName, myClassInfo.Namespace, myClassInfo.Name),
ResolveNamespaceLink(myClassInfo.AssemblyName, myClassInfo.Namespace),
ResolveAssemblyLink(myClassInfo.AssemblyName));
int sectionIndex = 0;
int sectionNameIndex = 0;
int classMembersGroupTypeIndex = 0;
while (Enum.IsDefined(typeof(ClassMembersGroups), classMembersGroupTypeIndex))
{
ClassMembersGroups classMembersGroupType = (ClassMembersGroups)classMembersGroupTypeIndex;
if (myClassInfo.GetMembersCount(classMembersGroupType) > 0)
{
WriteMembersIndex(sw, sectionsNames[sectionNameIndex++], sectionIndex,
myClassInfo.GetEnumerator(classMembersGroupType),
DEFAULT_MEMBERS_COLUMNS_NAMES,
TYPE_MEMBERS_COLUMNS_WIDTHS,
0, classMembersGroupType);
}
classMembersGroupTypeIndex++;
sectionIndex++;
}
WriteIndexFooter(sw);
sw.Close();
fs.Close();
}
private void WriteMembersIndex(StreamWriter sw, string sectionHeader, int sectionIndex, IEnumerator<ISummarisableMember> members, string[] columnsNames, int[] columnsWidthsPercentages, NamespaceMembersGroups namespaceMembersGroupsType, ClassMembersGroups classMembersGroupsType, bool dontResolveLinks)
{
WriteIndexSectionBegin(sw, sectionHeader, sectionIndex);
WriteIndexMembersTableBegin(sw, columnsNames, columnsWidthsPercentages);
while (members.MoveNext())
{
ISummarisableMember member = members.Current;
string summary = member.Summary;
string memberName = Utils.HTMLEncode(member.DisplayableName);
string link = null;
if (!dontResolveLinks)
{
link = ResolveLink((MetaClass)member);
}
IconsTypes iconsTypes = GetIconsTypes(member, namespaceMembersGroupsType, classMembersGroupsType);
WriteIndexMembersTableRow(sw,
memberName,
link,
summary,
Icons.GetFileNames(iconsTypes),
Icons.GetAltLabels(iconsTypes));
}
WriteIndexMembersTableEnd(sw);
WriteIndexSectionEnd(sw);
}
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; }
}
}
internal MyClassInfo FindNamespaceMember(string assemblyName, string namezpace, NamespaceMembersGroups namespaceMemberGroupType, string memberName)
{
MyNamespaceInfo myNamespaceInfo = FindNamespace(assemblyName, namezpace);
if (myNamespaceInfo == null)
{
return null;
}
return myNamespaceInfo.FindMember(namespaceMemberGroupType, memberName);
}
public static IconsTypes GetIconType(NamespaceMembersGroups namespaceMembersGroupType)
{
switch (namespaceMembersGroupType)
{
case NamespaceMembersGroups.PublicClasses: return IconsTypes.PublicClass;
case NamespaceMembersGroups.PublicStructures: return IconsTypes.PublicStructure;
case NamespaceMembersGroups.PublicInterfaces: return IconsTypes.PublicInterface;
case NamespaceMembersGroups.PublicEnumerations: return IconsTypes.PublicEnumeration;
case NamespaceMembersGroups.PublicDelegates: return IconsTypes.PublicDelegate;
case NamespaceMembersGroups.ProtectedInternalClasses: return IconsTypes.ProtectedInternalClass;
case NamespaceMembersGroups.ProtectedInternalStructures: return IconsTypes.ProtectedInternalStructure;
case NamespaceMembersGroups.ProtectedInternalInterfaces: return IconsTypes.ProtectedInternalInterface;
case NamespaceMembersGroups.ProtectedInternalEnumerations: return IconsTypes.ProtectedInternalEnumeration;
case NamespaceMembersGroups.ProtectedInternalDelegates: return IconsTypes.ProtectedInternalDelegate;
case NamespaceMembersGroups.ProtectedClasses: return IconsTypes.ProtectedClass;
case NamespaceMembersGroups.ProtectedStructures: return IconsTypes.ProtectedStructure;
case NamespaceMembersGroups.ProtectedInterfaces: return IconsTypes.ProtectedInterface;
case NamespaceMembersGroups.ProtectedEnumerations: return IconsTypes.ProtectedEnumeration;
case NamespaceMembersGroups.ProtectedDelegates: return IconsTypes.ProtectedDelegate;
case NamespaceMembersGroups.InternalClasses: return IconsTypes.InternalClass;
case NamespaceMembersGroups.InternalStructures: return IconsTypes.InternalStructure;
case NamespaceMembersGroups.InternalInterfaces: return IconsTypes.InternalInterface;
case NamespaceMembersGroups.InternalEnumerations: return IconsTypes.InternalEnumeration;
case NamespaceMembersGroups.InternalDelegates: return IconsTypes.InternalDelegate;
case NamespaceMembersGroups.PrivateClasses: return IconsTypes.PrivateClass;
case NamespaceMembersGroups.PrivateStructures: return IconsTypes.PrivateStructure;
case NamespaceMembersGroups.PrivateInterfaces: return IconsTypes.PrivateInterface;
case NamespaceMembersGroups.PrivateEnumerations: return IconsTypes.PrivateEnumeration;
case NamespaceMembersGroups.PrivateDelegates: return IconsTypes.PrivateDelegate;
default:
{
Debug.Assert(false, "Impossible! Couldn't return correct type of icon.");
return (IconsTypes)0;
}
}
}
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;
}
public static string GetBaseGroupName(NamespaceMembersGroups membersGroupType)
{
switch (membersGroupType)
{
case NamespaceMembersGroups.PublicClasses: { return("Classes"); }
case NamespaceMembersGroups.PublicStructures: { return("Structures"); }
case NamespaceMembersGroups.PublicInterfaces: { return("Interfaces"); }
case NamespaceMembersGroups.PublicDelegates: { return("Delegates"); }
case NamespaceMembersGroups.PublicEnumerations: { return("Enumerations"); }
case NamespaceMembersGroups.ProtectedInternalClasses: { return("Classes"); }
case NamespaceMembersGroups.ProtectedInternalStructures: { return("Structures"); }
case NamespaceMembersGroups.ProtectedInternalInterfaces: { return("Interfaces"); }
case NamespaceMembersGroups.ProtectedInternalDelegates: { return("Delegates"); }
case NamespaceMembersGroups.ProtectedInternalEnumerations: { return("Enumerations"); }
case NamespaceMembersGroups.ProtectedClasses: { return("Classes"); }
case NamespaceMembersGroups.ProtectedStructures: { return("Structures"); }
case NamespaceMembersGroups.ProtectedInterfaces: { return("Interfaces"); }
case NamespaceMembersGroups.ProtectedDelegates: { return("Delegates"); }
case NamespaceMembersGroups.ProtectedEnumerations: { return("Enumerations"); }
case NamespaceMembersGroups.InternalClasses: { return("Classes"); }
case NamespaceMembersGroups.InternalStructures: { return("Structures"); }
case NamespaceMembersGroups.InternalInterfaces: { return("Interfaces"); }
case NamespaceMembersGroups.InternalDelegates: { return("Delegates"); }
case NamespaceMembersGroups.InternalEnumerations: { return("Enumerations"); }
case NamespaceMembersGroups.PrivateClasses: { return("Classes"); }
case NamespaceMembersGroups.PrivateStructures: { return("Structures"); }
case NamespaceMembersGroups.PrivateInterfaces: { return("Interfaces"); }
case NamespaceMembersGroups.PrivateDelegates: { return("Delegates"); }
case NamespaceMembersGroups.PrivateEnumerations: { return("Enumerations"); }
default:
{
Debug.Assert(false, "Impossible! Couldn't recognize type of a namespace member.");
return(null);
}
}
}
internal IEnumerator<ISummarisableMember> GetEnumerator(NamespaceMembersGroups namespaceMembersGroupType)
{
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
Debug.Assert(false, "Impossible! Couldn't recognize members group ('" + namespaceMembersGroupType + "').");
yield break;
}
Dictionary<string, MetaClass> membersGroup = membersGroups[namespaceMembersGroupType];
List<string> sortedKeys = new List<string>();
sortedKeys.AddRange(membersGroup.Keys);
sortedKeys.Sort();
foreach (string key in sortedKeys)
{
yield return (ISummarisableMember)membersGroup[key];
}
}
public static IconsTypes GetIconType(NamespaceMembersGroups namespaceMembersGroupType)
{
switch (namespaceMembersGroupType)
{
case NamespaceMembersGroups.PublicClasses: return(IconsTypes.PublicClass);
case NamespaceMembersGroups.PublicStructures: return(IconsTypes.PublicStructure);
case NamespaceMembersGroups.PublicInterfaces: return(IconsTypes.PublicInterface);
case NamespaceMembersGroups.PublicEnumerations: return(IconsTypes.PublicEnumeration);
case NamespaceMembersGroups.PublicDelegates: return(IconsTypes.PublicDelegate);
case NamespaceMembersGroups.ProtectedInternalClasses: return(IconsTypes.ProtectedInternalClass);
case NamespaceMembersGroups.ProtectedInternalStructures: return(IconsTypes.ProtectedInternalStructure);
case NamespaceMembersGroups.ProtectedInternalInterfaces: return(IconsTypes.ProtectedInternalInterface);
case NamespaceMembersGroups.ProtectedInternalEnumerations: return(IconsTypes.ProtectedInternalEnumeration);
case NamespaceMembersGroups.ProtectedInternalDelegates: return(IconsTypes.ProtectedInternalDelegate);
case NamespaceMembersGroups.ProtectedClasses: return(IconsTypes.ProtectedClass);
case NamespaceMembersGroups.ProtectedStructures: return(IconsTypes.ProtectedStructure);
case NamespaceMembersGroups.ProtectedInterfaces: return(IconsTypes.ProtectedInterface);
case NamespaceMembersGroups.ProtectedEnumerations: return(IconsTypes.ProtectedEnumeration);
case NamespaceMembersGroups.ProtectedDelegates: return(IconsTypes.ProtectedDelegate);
case NamespaceMembersGroups.InternalClasses: return(IconsTypes.InternalClass);
case NamespaceMembersGroups.InternalStructures: return(IconsTypes.InternalStructure);
case NamespaceMembersGroups.InternalInterfaces: return(IconsTypes.InternalInterface);
case NamespaceMembersGroups.InternalEnumerations: return(IconsTypes.InternalEnumeration);
case NamespaceMembersGroups.InternalDelegates: return(IconsTypes.InternalDelegate);
case NamespaceMembersGroups.PrivateClasses: return(IconsTypes.PrivateClass);
case NamespaceMembersGroups.PrivateStructures: return(IconsTypes.PrivateStructure);
case NamespaceMembersGroups.PrivateInterfaces: return(IconsTypes.PrivateInterface);
case NamespaceMembersGroups.PrivateEnumerations: return(IconsTypes.PrivateEnumeration);
case NamespaceMembersGroups.PrivateDelegates: return(IconsTypes.PrivateDelegate);
default:
{
Debug.Assert(false, "Impossible! Couldn't return correct type of icon.");
return((IconsTypes)0);
}
}
}
private MyClassInfo FindGlobalNamespaceMember(string xmlMemberId)
{
int indexOfDot = -1;
while (true)
{
string potentialNamespace;
string potentialMemberName;
indexOfDot = xmlMemberId.IndexOf('.', indexOfDot + 1);
if (indexOfDot == -1)
{
potentialNamespace = MyNamespaceInfo.GLOBAL_NAMESPACE_NAME;
}
else
{
potentialNamespace = xmlMemberId.Substring(0, indexOfDot);
}
List <MyNamespaceInfo> namespacesInfos = assembliesInfo.FindNamespaces(potentialNamespace);
if (namespacesInfos.Count == 0)
{
if (indexOfDot == -1)
{
break;
}
else
{
continue;
}
}
if (indexOfDot + 1 < xmlMemberId.Length)
{
potentialMemberName = xmlMemberId.Substring(indexOfDot + 1).Replace('.', '/');
}
else
{
Logger.Warning("(XML) Malformed member ID: '{0}'.", xmlMemberId);
continue;
}
foreach (MyNamespaceInfo myNamespaceInfo in namespacesInfos)
{
int namespaceMembersGroupTypeIndex = 0;
while (Enum.IsDefined(typeof(NamespaceMembersGroups), namespaceMembersGroupTypeIndex))
{
NamespaceMembersGroups namespaceMembersGroupType = (NamespaceMembersGroups)namespaceMembersGroupTypeIndex;
MyClassInfo namespaceMember = myNamespaceInfo.FindMember(namespaceMembersGroupType, potentialMemberName);
if (namespaceMember != null)
{
return(namespaceMember);
}
namespaceMembersGroupTypeIndex++;
}
}
if (indexOfDot == -1)
{
break;
}
}
return(null);
}
public MyClassInfo FindMember(NamespaceMembersGroups namespaceMembersGroupType, string memberName)
{
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
return null;
}
Dictionary<string, MetaClass> membersGroup = membersGroups[namespaceMembersGroupType];
MetaClass member = null;
if (!membersGroup.ContainsKey(memberName))
{
// try indirect search (for generic types)
if (genericNamesMappings == null || !genericNamesMappings.ContainsKey(namespaceMembersGroupType))
{
return null;
}
Dictionary<string, string> genericNamesMappingsForGroup = genericNamesMappings[namespaceMembersGroupType];
if (!genericNamesMappingsForGroup.ContainsKey(memberName))
{
return null;
}
memberName = genericNamesMappingsForGroup[memberName];
if (!membersGroup.ContainsKey(memberName))
{
return null;
}
}
member = membersGroup[memberName];
Debug.Assert(member is MyClassInfo, "Impossible! All namespace member inherit from MyClassInfo.");
return (MyClassInfo)member;
}
internal MyClassInfo FindNamespaceMember(string assemblyName, string namezpace, NamespaceMembersGroups namespaceMemberGroupType, string memberName)
{
MyNamespaceInfo myNamespaceInfo = FindNamespace(assemblyName, namezpace);
if (myNamespaceInfo == null)
{
return(null);
}
return(myNamespaceInfo.FindMember(namespaceMemberGroupType, memberName));
}
public int GetMembersCount(NamespaceMembersGroups namespaceMembersGroupType)
{
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
return 0;
}
return membersGroups[namespaceMembersGroupType].Count;
}
private void WriteMembersIndex(StreamWriter sw, string sectionHeader, int sectionIndex, IEnumerator<ISummarisableMember> members, string[] columnsNames, int[] columnsWidthsPercentages, NamespaceMembersGroups namespaceMembersGroupsType, ClassMembersGroups classMembersGroupsType)
{
WriteMembersIndex(sw, sectionHeader, sectionIndex, members, columnsNames, columnsWidthsPercentages, namespaceMembersGroupsType, classMembersGroupsType, false);
}
public Dictionary<string, MetaClass> GetMembers(NamespaceMembersGroups namespaceMembersGroupType)
{
if (!membersGroups.ContainsKey(namespaceMembersGroupType))
{
return null;
}
return membersGroups[namespaceMembersGroupType];
}
private IconsTypes GetIconsTypes(ISummarisableMember member, NamespaceMembersGroups namespaceMembersGroupType, ClassMembersGroups classMembersGroupType)
{
if (member is MyAssemblyInfo) { return IconsTypes.Assembly; }
else if (member is MyNamespaceInfo) { return IconsTypes.Namespace; }
else if (member is MyClassInfo)
{
MyClassInfo myClassInfo = (MyClassInfo)member;
IconsTypes iconsTypes = Icons.GetIconType(namespaceMembersGroupType);
if (myClassInfo.IsAbstract && !myClassInfo.IsSealed) { iconsTypes |= IconsTypes.Abstract; }
if (myClassInfo.IsStatic) { iconsTypes |= IconsTypes.Static; }
if (myClassInfo is MyInterfaceInfo) { iconsTypes &= ~IconsTypes.Abstract; }
return iconsTypes;
}
else if (member is MyInvokableMembersOverloadsInfo)
{
MyInvokableMembersOverloadsInfo myInvokableMembersOverloadsInfo = (MyInvokableMembersOverloadsInfo)member;
MyInvokableMemberInfo myInvokableMemberInfo = null;
foreach (MyInvokableMemberInfo tmpMyInvokableMemberInfo in myInvokableMembersOverloadsInfo)
{
myInvokableMemberInfo = tmpMyInvokableMemberInfo;
break;
}
if (myInvokableMemberInfo == null)
{
Debug.Assert(false, "Impossible! There should be at least one overload.");
}
return GetIconsTypes(myInvokableMemberInfo, namespaceMembersGroupType, classMembersGroupType);
}
else if (member is MyPropertiesOverloadsInfo)
{
MyPropertiesOverloadsInfo myPropertiesOverloadsInfo = (MyPropertiesOverloadsInfo)member;
MyPropertyInfo myPropertyInfo = null;
foreach (MyPropertyInfo tmpMyPropertyInfo in myPropertiesOverloadsInfo)
{
myPropertyInfo = tmpMyPropertyInfo;
break;
}
if (myPropertyInfo == null)
{
Debug.Assert(false, "Impossible! There should be at least one overload.");
}
return GetIconsTypes(myPropertyInfo, namespaceMembersGroupType, classMembersGroupType);
}
else if (member is MyInvokableMemberInfo)
{
MyInvokableMemberInfo myInvokableMemberInfo = (MyInvokableMemberInfo)member;
IconsTypes iconsTypes = IconsTypes.None;
if (myInvokableMemberInfo.IsPublic) { iconsTypes = IconsTypes.PublicMethod; }
else if (myInvokableMemberInfo.IsProtectedInternal) { iconsTypes = IconsTypes.ProtectedInternalMethod; }
else if (myInvokableMemberInfo.IsProtected) { iconsTypes = IconsTypes.ProtectedMethod; }
else if (myInvokableMemberInfo.IsInternal) { iconsTypes = IconsTypes.InternalMethod; }
else if (myInvokableMemberInfo.IsPrivate) { iconsTypes = IconsTypes.PrivateMethod; }
if (myInvokableMemberInfo.IsStatic) { iconsTypes |= IconsTypes.Static; }
if (myInvokableMemberInfo.IsAbstract) { iconsTypes |= IconsTypes.Abstract; }
if (myInvokableMemberInfo.IsVirtual && !myInvokableMemberInfo.IsAbstract) { iconsTypes |= IconsTypes.Virtual; }
if (myInvokableMemberInfo.IsOverride && !myInvokableMemberInfo.IsSealed) { iconsTypes |= IconsTypes.Virtual; }
return iconsTypes;
}
else if (member is MyFieldInfo)
{
if (namespaceMembersGroupType == NamespaceMembersGroups.PublicEnumerations
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInternalEnumerations
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedEnumerations
|| namespaceMembersGroupType == NamespaceMembersGroups.InternalEnumerations
|| namespaceMembersGroupType == NamespaceMembersGroups.PrivateEnumerations)
{
IconsTypes iconsTypes = IconsTypes.EnumField;
return iconsTypes;
}
else
{
MyFieldInfo myFieldInfo = (MyFieldInfo)member;
IconsTypes iconsTypes = Icons.GetIconType(classMembersGroupType);
if (myFieldInfo.IsStatic) { iconsTypes |= IconsTypes.Static; }
if (myFieldInfo.IsConst) { iconsTypes |= IconsTypes.Static; }
return iconsTypes;
}
}
else if (member is MyPropertyInfo)
{
MyPropertyInfo myPropertyInfo = (MyPropertyInfo)member;
IconsTypes iconsTypes = Icons.GetIconType(classMembersGroupType);
if (myPropertyInfo.IsStatic) { iconsTypes |= IconsTypes.Static; }
if (myPropertyInfo.IsAbstract) { iconsTypes |= IconsTypes.Abstract; }
if (myPropertyInfo.IsVirtual && !myPropertyInfo.IsAbstract) { iconsTypes |= IconsTypes.Virtual; }
return iconsTypes;
}
else if (member is MyEventInfo)
{
MyEventInfo myEventInfo = (MyEventInfo)member;
IconsTypes iconsTypes = Icons.GetIconType(classMembersGroupType);
if (myEventInfo.IsStatic) { iconsTypes |= IconsTypes.Static; }
if (myEventInfo.IsAbstract) { iconsTypes |= IconsTypes.Abstract; }
if (myEventInfo.IsVirtual && !myEventInfo.IsAbstract) { iconsTypes |= IconsTypes.Virtual; }
return iconsTypes;
}
else if (member is MyNestedTypeInfo)
{
MyNestedTypeInfo myNestedTypeInfo = (MyNestedTypeInfo)member;
IconsTypes iconsTypes = Icons.GetIconType(classMembersGroupType);
if (myNestedTypeInfo.IsAbstract && !myNestedTypeInfo.IsSealed) { iconsTypes |= IconsTypes.Abstract; }
if (myNestedTypeInfo.IsStatic) { iconsTypes |= IconsTypes.Static; }
if (myNestedTypeInfo.MetaType == NestedTypes.Interface) { iconsTypes &= ~IconsTypes.Abstract; }
return iconsTypes;
}
else
{
Debug.Assert(false, "Impossible! Can't find icon for type " + member.GetType() + ".");
}
return IconsTypes.None;
}
public static string GetBaseGroupName(NamespaceMembersGroups membersGroupType)
{
switch (membersGroupType)
{
case NamespaceMembersGroups.PublicClasses: { return "Classes"; }
case NamespaceMembersGroups.PublicStructures: { return "Structures"; }
case NamespaceMembersGroups.PublicInterfaces: { return "Interfaces"; }
case NamespaceMembersGroups.PublicDelegates: { return "Delegates"; }
case NamespaceMembersGroups.PublicEnumerations: { return "Enumerations"; }
case NamespaceMembersGroups.ProtectedInternalClasses: { return "Classes"; }
case NamespaceMembersGroups.ProtectedInternalStructures: { return "Structures"; }
case NamespaceMembersGroups.ProtectedInternalInterfaces: { return "Interfaces"; }
case NamespaceMembersGroups.ProtectedInternalDelegates: { return "Delegates"; }
case NamespaceMembersGroups.ProtectedInternalEnumerations: { return "Enumerations"; }
case NamespaceMembersGroups.ProtectedClasses: { return "Classes"; }
case NamespaceMembersGroups.ProtectedStructures: { return "Structures"; }
case NamespaceMembersGroups.ProtectedInterfaces: { return "Interfaces"; }
case NamespaceMembersGroups.ProtectedDelegates: { return "Delegates"; }
case NamespaceMembersGroups.ProtectedEnumerations: { return "Enumerations"; }
case NamespaceMembersGroups.InternalClasses: { return "Classes"; }
case NamespaceMembersGroups.InternalStructures: { return "Structures"; }
case NamespaceMembersGroups.InternalInterfaces: { return "Interfaces"; }
case NamespaceMembersGroups.InternalDelegates: { return "Delegates"; }
case NamespaceMembersGroups.InternalEnumerations: { return "Enumerations"; }
case NamespaceMembersGroups.PrivateClasses: { return "Classes"; }
case NamespaceMembersGroups.PrivateStructures: { return "Structures"; }
case NamespaceMembersGroups.PrivateInterfaces: { return "Interfaces"; }
case NamespaceMembersGroups.PrivateDelegates: { return "Delegates"; }
case NamespaceMembersGroups.PrivateEnumerations: { return "Enumerations"; }
default:
{
Debug.Assert(false, "Impossible! Couldn't recognize type of a namespace member.");
return null;
}
}
}
private void ProcessNamespaceMember(MetaClass namespaceMember, NamespaceMembersGroups namespaceMembersGroupType)
{
MyClassInfo myClassInfo = (MyClassInfo)namespaceMember;
string namespaceDirName = GetNamespaceDirName(myClassInfo.Namespace);
string indexFileName = Utils.CombineMultiplePaths(myClassInfo.AssemblyName + "_" + myClassInfo.AssemblyName.GetHashCode(),
namespaceDirName,
"SM_" + myClassInfo.Name + "_" + myClassInfo.Name.GetHashCode() + ".html");
string filename = Utils.CombineMultiplePaths(outputDirectory, CONTENTS_DIRECTORY, GetAliasName(indexFileName));
FileStream fs = new FileStream(filename, FileMode.Create, FileAccess.Write);
StreamWriter sw = new StreamWriter(fs);
string memberTypeName = "";
switch (namespaceMembersGroupType)
{
case NamespaceMembersGroups.PublicClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.PublicDelegates: memberTypeName = "Delegate"; break;
case NamespaceMembersGroups.PublicEnumerations: memberTypeName = "Enumeration"; break;
case NamespaceMembersGroups.PublicInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.PublicStructures: memberTypeName = "Structure"; break;
case NamespaceMembersGroups.ProtectedInternalClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.ProtectedInternalDelegates: memberTypeName = "Delegate"; break;
case NamespaceMembersGroups.ProtectedInternalEnumerations: memberTypeName = "Enumeration"; break;
case NamespaceMembersGroups.ProtectedInternalInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.ProtectedInternalStructures: memberTypeName = "Structure"; break;
case NamespaceMembersGroups.ProtectedClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.ProtectedDelegates: memberTypeName = "Delegate"; break;
case NamespaceMembersGroups.ProtectedEnumerations: memberTypeName = "Enumeration"; break;
case NamespaceMembersGroups.ProtectedInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.ProtectedStructures: memberTypeName = "Structure"; break;
case NamespaceMembersGroups.InternalClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.InternalDelegates: memberTypeName = "Delegate"; break;
case NamespaceMembersGroups.InternalEnumerations: memberTypeName = "Enumeration"; break;
case NamespaceMembersGroups.InternalInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.InternalStructures: memberTypeName = "Structure"; break;
case NamespaceMembersGroups.PrivateClasses: memberTypeName = "Class"; break;
case NamespaceMembersGroups.PrivateDelegates: memberTypeName = "Delegate"; break;
case NamespaceMembersGroups.PrivateEnumerations: memberTypeName = "Enumeration"; break;
case NamespaceMembersGroups.PrivateInterfaces: memberTypeName = "Interface"; break;
case NamespaceMembersGroups.PrivateStructures: memberTypeName = "Structure"; break;
default: Debug.Assert(false, "Impossible! Couldn't obtain member's type name."); break;
}
string pageTitle = String.Format("{0} {1}", Utils.HTMLEncode(myClassInfo.Name.Replace('/', '.')), memberTypeName);
List<string> sectionsNames = new List<string>();
sectionsNames.Add("Syntax");
if (namespaceMember.Remarks != "")
{
sectionsNames.Add("Remarks");
}
if (namespaceMembersGroupType != NamespaceMembersGroups.PublicDelegates
&& namespaceMembersGroupType != NamespaceMembersGroups.ProtectedInternalDelegates
&& namespaceMembersGroupType != NamespaceMembersGroups.ProtectedDelegates
&& namespaceMembersGroupType != NamespaceMembersGroups.InternalDelegates
&& namespaceMembersGroupType != NamespaceMembersGroups.PrivateDelegates)
{
sectionsNames.Add("Members");
}
if (myClassInfo.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, myClassInfo.Summary);
string declaringTypeLink = null;
string declaringTypeName = GetDeclaringTypeNameOfANestedType(myClassInfo);
if (declaringTypeName != null)
{
declaringTypeLink = ResolveNamespaceMemberLink(myClassInfo.AssemblyName, myClassInfo.Namespace, declaringTypeName);
declaringTypeName = declaringTypeName.Replace('/', '.');
}
WriteIndexItemLocation(sw,
declaringTypeName,
myClassInfo.Namespace,
myClassInfo.AssemblyName,
declaringTypeLink,
ResolveNamespaceLink(myClassInfo.AssemblyName, myClassInfo.Namespace),
ResolveAssemblyLink(myClassInfo.AssemblyName));
int sectionIndex = 0;
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
string syntax = CreateNamespaceMemberSyntaxString((MyClassInfo)namespaceMember);
WriteIndexCodeBlockTable(sw, DEFAULT_LANGUAGE, syntax);
if (myClassInfo.GenericParametersCount > 0)
{
WriteGenericParametersDescriptions(sw, myClassInfo.GenericParameters);
}
if (namespaceMembersGroupType == NamespaceMembersGroups.PublicDelegates
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInternalDelegates
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedDelegates
|| namespaceMembersGroupType == NamespaceMembersGroups.InternalDelegates
|| namespaceMembersGroupType == NamespaceMembersGroups.PrivateDelegates)
{
MyDelegateInfo myDelegateInfo = (MyDelegateInfo)myClassInfo;
WriteParametersAndReturnValueDescriptions(sw, myDelegateInfo.ParametersNames, myDelegateInfo.Parameters,
myDelegateInfo.ReturnTypeFullName, myDelegateInfo.ReturnValueSummary, false);
}
WriteIndexSectionEnd(sw);
sectionIndex++;
if (namespaceMember.Remarks != "")
{
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
WriteIndexRemarks(sw, namespaceMember.Remarks);
WriteIndexSectionEnd(sw);
sectionIndex++;
}
if (namespaceMembersGroupType != NamespaceMembersGroups.PublicDelegates
&& namespaceMembersGroupType != NamespaceMembersGroups.ProtectedInternalDelegates
&& namespaceMembersGroupType != NamespaceMembersGroups.ProtectedDelegates
&& namespaceMembersGroupType != NamespaceMembersGroups.InternalDelegates
&& namespaceMembersGroupType != NamespaceMembersGroups.PrivateDelegates)
{
if (namespaceMembersGroupType == NamespaceMembersGroups.PublicEnumerations
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInternalEnumerations
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedEnumerations
|| namespaceMembersGroupType == NamespaceMembersGroups.InternalEnumerations
|| namespaceMembersGroupType == NamespaceMembersGroups.PrivateEnumerations)
{
if (myClassInfo.GetMembersCount(ClassMembersGroups.PublicFields) == 0)
{
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
WriteIndexText(sw, NO_MEMBERS);
WriteIndexSectionEnd(sw);
sectionIndex++;
}
else
{
WriteMembersIndex(sw, "Members",
sectionIndex,
myClassInfo.GetEnumerator(ClassMembersGroups.PublicFields),
ENUM_MEMBERS_COLUMNS_NAMES,
DEFAULT_MEMBERS_COLUMNS_WIDTHS,
namespaceMembersGroupType, 0);
sectionIndex++;
}
}
else // Classes, Structures and Interfaces
{
Debug.Assert(namespaceMembersGroupType == NamespaceMembersGroups.PublicClasses || namespaceMembersGroupType == NamespaceMembersGroups.PublicInterfaces || namespaceMembersGroupType == NamespaceMembersGroups.PublicStructures
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInternalClasses || namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInternalInterfaces || namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInternalStructures
|| namespaceMembersGroupType == NamespaceMembersGroups.ProtectedClasses || namespaceMembersGroupType == NamespaceMembersGroups.ProtectedInterfaces || namespaceMembersGroupType == NamespaceMembersGroups.ProtectedStructures
|| namespaceMembersGroupType == NamespaceMembersGroups.InternalClasses || namespaceMembersGroupType == NamespaceMembersGroups.InternalInterfaces || namespaceMembersGroupType == NamespaceMembersGroups.InternalStructures
|| namespaceMembersGroupType == NamespaceMembersGroups.PrivateClasses || namespaceMembersGroupType == NamespaceMembersGroups.PrivateInterfaces || namespaceMembersGroupType == NamespaceMembersGroups.PrivateStructures,
"Impossible! It must've been a class, a structure, an interface or an enumeration.");
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
sectionIndex++;
if (myClassInfo.HasMembers)
{
string href = Utils.CombineMultiplePaths(myClassInfo.AssemblyName + "_" + myClassInfo.AssemblyName.GetHashCode(),
namespaceDirName,
"MS_" + myClassInfo.Name + "_" + myClassInfo.Name.GetHashCode() + ".html");
sw.WriteLine("<p>Click <a href=\"{0}\">here</a> to see the list of members.</p>",
GetAliasName(href, true, true));
}
else
{
WriteIndexText(sw, NO_MEMBERS);
}
CreateNamespaceMemberMembersIndex(namespaceMember, namespaceMembersGroupType);
WriteIndexSectionEnd(sw);
}
}
if (myClassInfo.Example != "")
{
Debug.Assert(sectionsNames[sectionIndex] == "Example", "There should be 'Example' section now.");
WriteIndexSectionBegin(sw, sectionsNames[sectionIndex], sectionIndex);
WriteIndexExample(sw, myClassInfo.Example);
WriteIndexSectionEnd(sw);
sectionIndex++;
}
WriteIndexFooter(sw);
sw.Close();
fs.Close();
ProcessNamespaceMemberMembers(myClassInfo, namespaceMembersGroupType);
}
public static string NamespaceMembersGroupToString(NamespaceMembersGroups membersGroupType)
{
switch (membersGroupType)
{
case NamespaceMembersGroups.PublicClasses: { return("Публичные Классы"); }
case NamespaceMembersGroups.PublicStructures: { return("Публичные Структуры"); }
case NamespaceMembersGroups.PublicInterfaces: { return("Публичные Интерфейсы"); }
case NamespaceMembersGroups.PublicDelegates: { return("Публичные Делегаты"); }
case NamespaceMembersGroups.PublicEnumerations: { return("Публичные Перечни"); }
case NamespaceMembersGroups.ProtectedInternalClasses: { return("Защищённые Внутренние Классы"); }
case NamespaceMembersGroups.ProtectedInternalStructures: { return("Защищённые Внутренние Структуры"); }
case NamespaceMembersGroups.ProtectedInternalInterfaces: { return("Защищённые Внутренние Интерфейсы"); }
case NamespaceMembersGroups.ProtectedInternalDelegates: { return("Защищённые Внутренние Делегаты"); }
case NamespaceMembersGroups.ProtectedInternalEnumerations: { return("Защищённые Внутренние Перечни"); }
case NamespaceMembersGroups.ProtectedClasses: { return("Защищённые Классы"); }
case NamespaceMembersGroups.ProtectedStructures: { return("Защищённые Структуры"); }
case NamespaceMembersGroups.ProtectedInterfaces: { return("Защищённые Интерфейсы"); }
case NamespaceMembersGroups.ProtectedDelegates: { return("Защищённые Делегаты"); }
case NamespaceMembersGroups.ProtectedEnumerations: { return("Защищённые Перечни"); }
case NamespaceMembersGroups.InternalClasses: { return("Внутренние Классы"); }
case NamespaceMembersGroups.InternalStructures: { return("Внутренние Структуры"); }
case NamespaceMembersGroups.InternalInterfaces: { return("Внутренние Интерфейсы"); }
case NamespaceMembersGroups.InternalDelegates: { return("Внутренние Делегаты"); }
case NamespaceMembersGroups.InternalEnumerations: { return("Внутренние Перечни"); }
case NamespaceMembersGroups.PrivateClasses: { return("Приватные Классы"); }
case NamespaceMembersGroups.PrivateStructures: { return("Приватные Структуры"); }
case NamespaceMembersGroups.PrivateInterfaces: { return("Приватные Интерфейсы"); }
case NamespaceMembersGroups.PrivateDelegates: { return("Приватные Делегаты"); }
case NamespaceMembersGroups.PrivateEnumerations: { return("Приватные Перечни"); }
default:
{
Debug.Assert(false, "Impossible! Couldn't recognize type of a namespace member.");
return(null);
}
}
}
