private static Block ParseBlock(AssemblyDef assembly, XmlCodeElement element, ParsingSession session)
{
TraceHelper.WriteLine("parsing-block: e({0})", element.Element.ToString());
CrefEntryKey crefEntryKey;
Inline link;
string displayName;
switch (element.Element)
{
// Invalid inline elements
case XmlCodeElements.C:
case XmlCodeElements.ParamRef:
case XmlCodeElements.See:
case XmlCodeElements.SeeAlso:
case XmlCodeElements.Text:
case XmlCodeElements.TypeParamRef:
InvalidOperationException ex = new InvalidOperationException(
"Found an inline element where a block level element was expected."
);
ex.Data["element"] = element;
throw ex;
case XmlCodeElements.Include:
InvalidOperationException includeEx = new InvalidOperationException(
"Found an include comment element, the c# parser has failed."
);
includeEx.Data["element"] = element;
throw includeEx;
// End points
case XmlCodeElements.Code:
return(new Code(element.Text));
case XmlCodeElements.Exception:
ExceptionXmlCodeElement exceptionElement = element as ExceptionXmlCodeElement;
if (Parser.ResolveMember(exceptionElement.Text, exceptionElement.Member, assembly, out crefEntryKey, out displayName))
{
link = link = Parser.CreateHyperlink(crefEntryKey, exceptionElement.Member.TypeName);
}
else
{
if (string.IsNullOrEmpty(displayName))
{
link = new Run(exceptionElement.Member.TypeName);
}
else
{
link = new Run(displayName);
}
}
return(new ExceptionEntry(link, Parser.Parse(assembly, element as ExceptionXmlCodeElement)));
case XmlCodeElements.Example:
ExampleXmlCodeElement exampleElement = element as ExampleXmlCodeElement;
return(new Example(Parser.Parse(assembly, exampleElement)));
case XmlCodeElements.Para:
ParaXmlCodeElement paraElement = element as ParaXmlCodeElement;
return(new Para(Parser.Parse(assembly, paraElement)));
case XmlCodeElements.Permission:
PermissionXmlCodeElement permissionElement = element as PermissionXmlCodeElement;
if (Parser.ResolveMember(permissionElement.Text, permissionElement.Member, assembly, out crefEntryKey, out displayName))
{
link = link = Parser.CreateHyperlink(crefEntryKey, permissionElement.Member.TypeName);
}
else
{
if (string.IsNullOrEmpty(displayName))
{
link = new Run(permissionElement.Member.TypeName);
}
else
{
link = new Run(displayName);
}
}
return(new PermissionEntry(link, Parser.Parse(assembly, element as PermissionXmlCodeElement)));
case XmlCodeElements.Remarks:
return(new Remarks(Parser.Parse(assembly, element as RemarksXmlCodeElement)));
case XmlCodeElements.Returns:
return(new Returns(Parser.Parse(assembly, element as ReturnsXmlCodeElement)));
case XmlCodeElements.Summary:
return(new Summary(Parser.Parse(assembly, element as SummaryXmlCodeElement)));
case XmlCodeElements.Value:
return(new Value(Parser.Parse(assembly, element as ValueXmlCodeElement)));
case XmlCodeElements.Param:
return(new Param(((ParamXmlCodeElement)element).Name, Parser.Parse(assembly, element as ParamXmlCodeElement)));
case XmlCodeElements.TypeParam:
TypeParamXmlCodeElement typeParamElement = (TypeParamXmlCodeElement)element;
return(new TypeParamEntry(typeParamElement.Name, typeParamElement.Text));
case XmlCodeElements.List:
ListXmlCodeElement listElement = (ListXmlCodeElement)element;
return(Parser.ParseList(assembly, listElement));
case XmlCodeElements.Term:
case XmlCodeElements.Description:
Section termOrDescription = new Section();
termOrDescription.Blocks.AddRange(Parser.Parse(assembly, (XmlContainerCodeElement)element));
return(termOrDescription);
break;
}
throw new Exception("WTF, block parsing error");
}
/// <summary>
/// Renders the list of defined exceptions for the specified <paramref name="member"/>.
/// </summary>
/// <param name="member">The member to render the exceptions for.</param>
/// <param name="writer">The writer to write the exceptions to.</param>
/// <param name="comment">The XmlCodeComment to read the exceptions from.</param>
protected virtual void RenderExceptionBlock(ReflectedMember member, System.Xml.XmlWriter writer, XmlCodeComment comment)
{
// output documentation for expected exceptions if they are defined
if (comment != XmlCodeComment.Empty)
{
List <XmlCodeElement> exceptions = comment.Elements.FindAll(node => node is ExceptionXmlCodeElement);
if (exceptions != null && exceptions.Count > 0)
{
writer.WriteStartElement("exceptions");
for (int i = 0; i < exceptions.Count; i++)
{
ExceptionXmlCodeElement current = (ExceptionXmlCodeElement)exceptions[i];
string exceptionName = string.Empty;
ReflectedMember found = null;
if (current.Member.PathType != CRefTypes.Error)
{
TypeDef def = member.Assembly.FindType(current.Member.Namespace, current.Member.TypeName);
exceptionName = string.Format("{0}.{1}", current.Member.Namespace, current.Member.TypeName);
if (def != null)
{
found = def;
switch (current.Member.PathType)
{
// these elements are named and the type of element will
// not modify how it should be displayed
case CRefTypes.Field:
case CRefTypes.Property:
case CRefTypes.Event:
case CRefTypes.Namespace:
break;
// these could be generic and so will need to modify to
// a more appropriate display name
case CRefTypes.Method:
MethodDef method = current.Member.FindIn(def) as MethodDef;
if (method != null)
{
found = method;
exceptionName = method.GetDisplayName(false);
}
break;
case CRefTypes.Type:
exceptionName = def.GetDisplayName(false);
break;
}
}
}
writer.WriteStartElement("exception");
writer.WriteStartElement("name");
if (found != null)
{
writer.WriteAttributeString("key", found.GetGloballyUniqueId().ToString());
writer.WriteAttributeString("cref", current.Member.ToString());
}
writer.WriteString(exceptionName);
writer.WriteEndElement();
writer.WriteStartElement("condition");
for (int j = 0; j < current.Elements.Count; j++)
{
this.Serialize(current.Elements[j], writer);
}
writer.WriteEndElement();
writer.WriteEndElement();
}
writer.WriteEndElement();
}
}
}
