private static bool TryFormatAtom10Entry(Atom10Entry entryToFormat, XNamespaceAliasSet namespaceAliases, ExtensionManifestDirectory extensionManifestDirectory, out XElement entryElement)
{
entryElement = default;
if (entryToFormat == null)
{
return(false);
}
entryElement = new XElement(_atom + "entry");
if (TryFormatAtom10RequiredTextElement(entryToFormat.Id, _atom + "id", out var idElement))
{
entryElement.Add(idElement);
}
if (TryFormatAtom10TextRequired(entryToFormat.Title, _atom + "title", out var titleElement))
{
entryElement.Add(titleElement);
}
if (TryFormatAtom10TimestampRequired(entryToFormat.Updated, _atom + "updated", out var updatedElement))
{
entryElement.Add(updatedElement);
}
foreach (var authorToFormat in entryToFormat.Authors)
{
if (TryFormatAtom10Person(authorToFormat, _atom + "author", out var authorElement))
{
entryElement.Add(authorElement);
}
}
if (TryFormatAtom10Content(entryToFormat.Content, out var contentElement))
{
entryElement.Add(contentElement);
}
foreach (var linkToFormat in entryToFormat.Links)
{
if (TryFormatAtom10Link(linkToFormat, out var linkElement))
{
entryElement.Add(linkElement);
}
}
if (TryFormatAtom10TextOptional(entryToFormat.Summary, _atom + "summary", out var summaryElement))
{
entryElement.Add(summaryElement);
}
foreach (var categoryToFormat in entryToFormat.Categories)
{
if (TryFormatAtom10Category(categoryToFormat, out var categoryElement))
{
entryElement.Add(categoryElement);
}
}
foreach (var contributorToFormat in entryToFormat.Contributors)
{
if (TryFormatAtom10Person(contributorToFormat, _atom + "contributor", out var contributorElement))
{
entryElement.Add(contributorElement);
}
}
if (TryFormatAtom10TimestampOptional(entryToFormat.Published, _atom + "published", out var publishedElement))
{
entryElement.Add(publishedElement);
}
if (TryFormatAtom10TextOptional(entryToFormat.Rights, _atom + "rights", out var rightsElement))
{
entryElement.Add(rightsElement);
}
if (TryFormatAtom10Source(entryToFormat.Source, out var sourceElement))
{
entryElement.Add(sourceElement);
}
// extensions
if (ExtensibleEntityFormatter.TryFormatXElementExtensions(entryToFormat, namespaceAliases, extensionManifestDirectory, out var extensionElements))
{
entryElement.AddRange(extensionElements);
}
return(true);
}
private static bool TryParseAtom10Entry(XElement entryElement, XNamespace atom, ExtensionManifestDirectory extensionManifestDirectory, out Atom10Entry parsedEntry)
{
parsedEntry = default;
if (entryElement == null)
{
return(false);
}
parsedEntry = new Atom10Entry();
parsedEntry.Id = entryElement.Element(atom + "id")?.Value.Trim();
if (TryParseAtom10Text(entryElement.Element(atom + "title"), out var parsedTitle))
{
parsedEntry.Title = parsedTitle;
}
if (TryParseAtom10Timestamp(entryElement.Element(atom + "updated"), out var parsedUpdated))
{
parsedEntry.Updated = parsedUpdated;
}
foreach (var authorElement in entryElement.Elements(atom + "author"))
{
if (TryParseAtom10Person(authorElement, atom, out var parsedPerson))
{
parsedEntry.Authors.Add(parsedPerson);
}
}
if (TryParseAtom10Content(entryElement.Element(atom + "content"), out var parsedContent))
{
parsedEntry.Content = parsedContent;
}
foreach (var linkElement in entryElement.Elements(atom + "link"))
{
if (TryParseAtom10Link(linkElement, out var parsedLink))
{
parsedEntry.Links.Add(parsedLink);
}
}
if (TryParseAtom10Text(entryElement.Element(atom + "summary"), out var parsedSummary))
{
parsedEntry.Summary = parsedSummary;
}
foreach (var categoryElement in entryElement.Elements(atom + "category"))
{
if (TryParseAtom10Category(categoryElement, out var parsedCategory))
{
parsedEntry.Categories.Add(parsedCategory);
}
}
foreach (var contributorElement in entryElement.Elements(atom + "contributor"))
{
if (TryParseAtom10Person(contributorElement, atom, out var parsedPerson))
{
parsedEntry.Contributors.Add(parsedPerson);
}
}
if (TryParseAtom10Timestamp(entryElement.Element(atom + "published"), out var parsedPublished))
{
parsedEntry.Published = parsedPublished;
}
if (TryParseAtom10Text(entryElement.Element(atom + "rights"), out var parsedRights))
{
parsedEntry.Rights = parsedRights;
}
if (TryParseAtom10Source(entryElement.Element(atom + "source"), atom, out var parsedSource))
{
parsedEntry.Source = parsedSource;
}
// extensions
ExtensibleEntityParser.ParseXElementExtensions(entryElement, extensionManifestDirectory, parsedEntry);
return(true);
}
