public override void Write(DocumentFormatter output, OutputContext context) { if (Overloads.Count == 0) { base.Write(output, context); return; } output.Header(1, SharedTitle); WriteInfoBox(output, context); WriteOverloadsSummary(output, context); output.Table(new[] { "Overload", "Description" }, Overloads, overload => overload.WriteLink(output, context), overload => overload.WriteSummaryLine(output, context) ); foreach (var overload in Overloads) { output.Header(2, overload.Name); overload.WriteSummary(output, context); var syntax = overload.GetSyntax(context.Language); if (!string.IsNullOrEmpty(syntax)) { output.Header(3, "Syntax"); output.Code(syntax, context.Language.Name); } overload.WriteDetails(3, output, context); } }
public override void Write(DocumentFormatter output, OutputContext context) { output.Header(1, Title); WriteInfoBox(output, context); WriteSummary(output, context); var syntax = GetSyntax(context.Language); if (!string.IsNullOrEmpty(syntax)) { output.Header(2, "Syntax"); output.Code(syntax, context.Language.Name); } WriteDetails(2, output, context); }
public virtual void WriteParametersSection(int level, DocumentFormatter output, OutputContext context, IEnumerable <ParameterInfo> parameters) { if (parameters == null || !parameters.Any()) { return; } var doc = context.Document.Of(this); output.Header(level, "Parameters"); output.DefinitionList(parameters, parameter => { output.Text(parameter.Name, TextStyles.Teletype); output.Text(": "); if (parameter.ParameterType.IsGenericParameter) { output.Text(parameter.ParameterType.GetDisplayName(), TextStyles.Emphasize); } else { output.LinkCRef(parameter.ParameterType.GetCRef(), parameter.ParameterType.GetDisplayName()); } }, parameter => output.Section(() => doc?.Parameters.For(parameter.Name, output.Xml, name => Log.WarnMisisngParameterDoc(this, name)))); }
protected virtual void WriteThreadSafetySection(int level, DocumentFormatter output, IEnumerable <XmlThreadSafety> threadSafeties) { var threadSafety = threadSafeties?.FirstOrDefault(); if (threadSafety == null) { return; } output.Header(level, "Thread Safety"); if (threadSafety.Static && threadSafety.Instance) { output.Section("Any public member of this type, either static or instance, is thread-safe."); } else if (threadSafety.Static && !threadSafety.Instance) { output.Section("Any public static member of this type is thread-safe, but instance members are not guaranteed to be thread-safe."); } else if (!threadSafety.Static && threadSafety.Instance) { output.Section("Any public static member of this type is not guaranteed to be thread-safe, but instance members are thread-safe."); } else { output.Section("Neither public nor instance members of this type are guaranteed to be thread-safe."); } }
protected void WriteTypesInCategory(DocumentFormatter output, OutputContext context, TypeCategory category, IEnumerable <ClrType> types) { output.Header(3, category.ToPluralString()); output.Table(new[] { category.ToString(), "Description" }, types, type => type.WriteLink(output, context), type => type.WriteSummaryLine(output, context) ); }
protected void WriteMembersInCategory(int level, DocumentFormatter output, OutputContext context, MemberCategory category, IEnumerable <ClrMember> members) { output.Header(level, category.ToPluralString()); output.Table(new[] { category.ToString(), "Description" }, members, member => member.WriteLink(output, context), member => member.WriteSummaryLine(output, context) ); }
public override void WriteMembers(int level, DocumentFormatter output, OutputContext context) { output.Header(level, "Members"); output.Table(new[] { "Name", "Value", "Description" }, Info.GetEnumValues().Cast <Enum>(), value => output.Text(Info.GetEnumName(value)), value => output.Text((value as IFormattable)?.ToString("D", CultureInfo.InvariantCulture)), value => context.Document.Members.For(value.GetCRef(), doc => output.Xml(doc.Summaries.FirstOrDefault())) ); }
public override void Write(DocumentFormatter output, OutputContext context) { output.Header(2, Title); WriteSummaryLine(output, context); foreach (var typeCategory in TypeCategories.OrderBy(group => group.Key)) { WriteTypesInCategory(output, context, typeCategory.Key, typeCategory); typeCategory.ForEach(context.Compose); } }
protected virtual void WriteSection(DocumentFormatter output, int level, string header, IEnumerable <XmlNode> items) { if (items == null || !items.Any()) { return; } if (!string.IsNullOrEmpty(header)) { output.Header(level, header); } output.Xml(items); }
protected virtual void WriteSection(DocumentFormatter output, int level, string header, IEnumerable <ICRef> items) { if (items == null || !items.Any()) { return; } if (!string.IsNullOrEmpty(header)) { output.Header(level, header); } output.List(items, item => output.LinkCRef(item.CRef, (item as ClrItem)?.Title)); }
protected virtual void WriteSection(DocumentFormatter output, int level, string header, string label, IEnumerable <XmlReferenceNode> items) { if (items == null || !items.Any()) { return; } if (!string.IsNullOrEmpty(header)) { output.Header(level, header); } output.Table(new[] { label, "Description" }, items, item => output.LinkCRef(item.CRef, Utils.FormatCRef(item.CRef)), item => output.Xml(item)); }
public virtual void WriteTypeParametersSection(int level, DocumentFormatter output, OutputContext context, IEnumerable <Type> typeParameters) { if (typeParameters == null || !typeParameters.Any()) { return; } var doc = context.Document.Of(this); output.Header(level, "Type Parameters"); output.DefinitionList(typeParameters, typeParameter => output.Text(typeParameter.Name, TextStyles.Teletype), typeParameter => output.Section(() => { if (WriteTypeParamDoc(doc, typeParameter.Name)) { return; } if (!typeParameter.IsGenericMethodParameter) { for (var parent = Owner; parent != null; parent = parent.Owner) { if (WriteTypeParamDoc(context.Document.Of(parent), typeParameter.Name)) { return; } } } Log.WarnMisisngTypeParameterDoc(this, typeParameter.Name); })); bool WriteTypeParamDoc(XmlMember ownerDoc, string paramName) { if (ownerDoc != null && ownerDoc.TypeParameters.TryGetValue(paramName, out var paramDoc)) { output.Xml(paramDoc); return(true); } return(false); } }
public virtual void WriteReturnValueSection(int level, DocumentFormatter output, OutputContext context, Type returnType) { if (returnType == null || returnType == typeof(void)) { return; } var doc = context.Document.Of(this); if (doc != null && doc.Returns.Count == 0) { Log.WarnMisisngReturnDoc(this); } output.Header(level, "Return Value"); output.DefinitionList(new[] { returnType }, type => output.LinkCRef(type.GetCRef(), type.GetDisplayName()), type => output.Xml(doc?.Returns)); }
protected virtual void WriteSection(DocumentFormatter output, int level, string header, IEnumerable <XmlRevisionHistory> items) { var revisions = items?.Where(item => item.IsVisible).SelectMany(item => item.Revisions.Where(revision => revision.IsVisible)); if (revisions == null || !revisions.Any()) { return; } if (!string.IsNullOrEmpty(header)) { output.Header(level, header); } output.Table(new[] { "Date", "Version", "Author", "Description" }, revisions, revision => output.Text(revision.Date), revision => output.Text(revision.Version), revision => output.Text(revision.Author), revision => output.Xml(revision)); }
public override void Write(DocumentFormatter output, OutputContext context) { output.Header(1, Title); WriteSummaryLine(output, context); Namespaces.OrderBy(ns => ns.Name).ForEach(ns => ns.Write(output, context)); }