/// <summary>Consumes the next chunk of content from the underlying XML reader.</summary>
/// <returns>
/// true if another piece of content is available, identified by DataKind.
/// false if there is no more content.
/// </returns>
internal bool Read()
{
// When an external caller 'insists', we'll come all the way down (which is the 'most local'
// scope at which this is known), and unwind as a no-op.
if (this.DataKind == AtomDataKind.Finished)
{
return false;
}
while (this.reader.Read())
{
if (ShouldIgnoreNode(this.reader))
{
continue;
}
Debug.Assert(
this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement,
"this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement -- otherwise we should have ignored or thrown");
AtomDataKind readerData = ParseStateForReader(this.reader);
if (this.reader.NodeType == XmlNodeType.EndElement)
{
// The only case in which we expect to see an end-element at the top level
// is for a feed. Custom elements and entries should be consumed by
// their own parsing methods. However we are tolerant of additional EndElements,
// which at this point mean we have nothing else to consume.
break;
}
switch (readerData)
{
case AtomDataKind.Custom:
if (this.DataKind == AtomDataKind.None)
{
this.kind = AtomDataKind.Custom;
return true;
}
else
{
MaterializeAtom.SkipToEnd(this.reader);
continue;
}
case AtomDataKind.Entry:
this.kind = AtomDataKind.Entry;
this.ParseCurrentEntry(out this.entry);
return true;
case AtomDataKind.Feed:
if (this.DataKind == AtomDataKind.None)
{
this.feed = new AtomFeed();
this.kind = AtomDataKind.Feed;
return true;
}
throw new InvalidOperationException(Strings.AtomParser_FeedUnexpected);
case AtomDataKind.FeedCount:
this.ParseCurrentFeedCount();
break;
case AtomDataKind.PagingLinks:
if (this.feed == null)
{
// paging link outside of feed?
throw new InvalidOperationException(Strings.AtomParser_PagingLinkOutsideOfFeed);
}
this.kind = AtomDataKind.PagingLinks;
this.ParseCurrentFeedPagingLinks();
return true;
default:
Debug.Assert(false, "Atom Parser is in a wrong state...Did you add a new AtomDataKind?");
break;
}
}
this.kind = AtomDataKind.Finished;
this.entry = null;
return false;
}
internal bool Read()
{
if (this.DataKind == AtomDataKind.Finished)
{
return false;
}
while (this.reader.Read())
{
if (ShouldIgnoreNode(this.reader))
{
continue;
}
Debug.Assert(
this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement,
"this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement -- otherwise we should have ignored or thrown");
AtomDataKind readerData = ParseStateForReader(this.reader);
if (this.reader.NodeType == XmlNodeType.EndElement)
{
break;
}
switch (readerData)
{
case AtomDataKind.Custom:
if (this.DataKind == AtomDataKind.None)
{
this.kind = AtomDataKind.Custom;
return true;
}
else
{
MaterializeAtom.SkipToEnd(this.reader);
continue;
}
case AtomDataKind.Entry:
this.kind = AtomDataKind.Entry;
this.ParseCurrentEntry(out this.entry);
return true;
case AtomDataKind.Feed:
if (this.DataKind == AtomDataKind.None)
{
this.feed = new AtomFeed();
this.kind = AtomDataKind.Feed;
return true;
}
throw new InvalidOperationException(Strings.AtomParser_FeedUnexpected);
case AtomDataKind.FeedCount:
this.ParseCurrentFeedCount();
break;
case AtomDataKind.PagingLinks:
if (this.feed == null)
{
throw new InvalidOperationException(Strings.AtomParser_PagingLinkOutsideOfFeed);
}
this.kind = AtomDataKind.PagingLinks;
this.ParseCurrentFeedPagingLinks();
return true;
default:
Debug.Assert(false, "Atom Parser is in a wrong state...Did you add a new AtomDataKind?");
break;
}
}
this.kind = AtomDataKind.Finished;
this.entry = null;
return false;
}
internal bool Read()
{
if (this.DataKind == AtomDataKind.Finished)
{
return(false);
}
while (this.reader.Read())
{
if (ShouldIgnoreNode(this.reader))
{
continue;
}
Debug.Assert(
this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement,
"this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement -- otherwise we should have ignored or thrown");
AtomDataKind readerData = ParseStateForReader(this.reader);
if (this.reader.NodeType == XmlNodeType.EndElement)
{
break;
}
switch (readerData)
{
case AtomDataKind.Custom:
if (this.DataKind == AtomDataKind.None)
{
this.kind = AtomDataKind.Custom;
return(true);
}
else
{
MaterializeAtom.SkipToEnd(this.reader);
continue;
}
case AtomDataKind.Entry:
this.kind = AtomDataKind.Entry;
this.ParseCurrentEntry(out this.entry);
return(true);
case AtomDataKind.Feed:
if (this.DataKind == AtomDataKind.None)
{
this.feed = new AtomFeed();
this.kind = AtomDataKind.Feed;
return(true);
}
throw new InvalidOperationException(Strings.AtomParser_FeedUnexpected);
case AtomDataKind.FeedCount:
this.ParseCurrentFeedCount();
break;
case AtomDataKind.PagingLinks:
if (this.feed == null)
{
throw new InvalidOperationException(Strings.AtomParser_PagingLinkOutsideOfFeed);
}
this.kind = AtomDataKind.PagingLinks;
this.ParseCurrentFeedPagingLinks();
return(true);
default:
Debug.Assert(false, "Atom Parser is in a wrong state...Did you add a new AtomDataKind?");
break;
}
}
this.kind = AtomDataKind.Finished;
this.entry = null;
return(false);
}
private void ParseCurrentLink(AtomEntry targetEntry)
{
Debug.Assert(targetEntry != null, "targetEntry != null");
Debug.Assert(
this.reader.NodeType == XmlNodeType.Element,
"this.reader.NodeType == XmlNodeType.Element -- otherwise we shouldn't try to parse a link");
Debug.Assert(
this.reader.LocalName == "link",
"this.reader.LocalName == 'link' -- otherwise we shouldn't try to parse a link");
string relation = this.reader.GetAttribute(XmlConstants.AtomLinkRelationAttributeName);
if (relation == null)
{
return;
}
if (relation == XmlConstants.AtomEditRelationAttributeValue && targetEntry.EditLink == null)
{
string href = this.reader.GetAttribute(XmlConstants.AtomHRefAttributeName);
if (String.IsNullOrEmpty(href))
{
throw Error.InvalidOperation(Strings.Context_MissingEditLinkInResponseBody);
}
targetEntry.EditLink = this.ConvertHRefAttributeValueIntoURI(href);
}
else if (relation == XmlConstants.AtomSelfRelationAttributeValue && targetEntry.QueryLink == null)
{
string href = this.reader.GetAttribute(XmlConstants.AtomHRefAttributeName);
if (String.IsNullOrEmpty(href))
{
throw Error.InvalidOperation(Strings.Context_MissingSelfLinkInResponseBody);
}
targetEntry.QueryLink = this.ConvertHRefAttributeValueIntoURI(href);
}
else if (relation == XmlConstants.AtomEditMediaRelationAttributeValue && targetEntry.MediaEditUri == null)
{
string href = this.reader.GetAttribute(XmlConstants.AtomHRefAttributeName);
if (String.IsNullOrEmpty(href))
{
throw Error.InvalidOperation(Strings.Context_MissingEditMediaLinkInResponseBody);
}
targetEntry.MediaEditUri = this.ConvertHRefAttributeValueIntoURI(href);
targetEntry.StreamETagText = this.reader.GetAttribute(XmlConstants.AtomETagAttributeName, XmlConstants.DataWebMetadataNamespace);
}
if (!this.reader.IsEmptyElement)
{
string propertyName = UriUtil.GetNameFromAtomLinkRelationAttribute(relation);
if (propertyName == null)
{
return;
}
string propertyValueText = this.reader.GetAttribute(XmlConstants.AtomTypeAttributeName);
bool isFeed;
if (!IsAllowedLinkType(propertyValueText, out isFeed))
{
return;
}
if (!ReadChildElement(this.reader, XmlConstants.AtomInlineElementName, XmlConstants.DataWebMetadataNamespace))
{
return;
}
bool emptyInlineCollection = this.reader.IsEmptyElement;
object propertyValue = null;
if (!emptyInlineCollection)
{
AtomFeed nestedFeed = null;
AtomEntry nestedEntry = null;
List <AtomEntry> feedEntries = null;
Debug.Assert(this.reader is Xml.XmlWrappingReader, "reader must be a instance of XmlWrappingReader");
string readerBaseUri = this.reader.BaseURI;
XmlReader nestedReader = Xml.XmlWrappingReader.CreateReader(readerBaseUri, this.reader.ReadSubtree());
nestedReader.Read();
Debug.Assert(nestedReader.LocalName == "inline", "nestedReader.LocalName == 'inline'");
AtomParser nested = new AtomParser(nestedReader, this.entryCallback, this.typeScheme, this.currentDataNamespace);
while (nested.Read())
{
switch (nested.DataKind)
{
case AtomDataKind.Feed:
feedEntries = new List <AtomEntry>();
nestedFeed = nested.CurrentFeed;
propertyValue = nestedFeed;
break;
case AtomDataKind.Entry:
nestedEntry = nested.CurrentEntry;
if (feedEntries != null)
{
feedEntries.Add(nestedEntry);
}
else
{
propertyValue = nestedEntry;
}
break;
case AtomDataKind.PagingLinks:
break;
default:
throw new InvalidOperationException(Strings.AtomParser_UnexpectedContentUnderExpandedLink);
}
}
if (nestedFeed != null)
{
Debug.Assert(
nestedFeed.Entries == null,
"nestedFeed.Entries == null -- otherwise someone initialized this for us");
nestedFeed.Entries = feedEntries;
}
}
AtomContentProperty property = new AtomContentProperty();
property.Name = propertyName;
if (emptyInlineCollection || propertyValue == null)
{
property.IsNull = true;
if (isFeed)
{
property.Feed = new AtomFeed();
property.Feed.Entries = Enumerable.Empty <AtomEntry>();
}
else
{
property.Entry = new AtomEntry();
property.Entry.IsNull = true;
}
}
else
{
property.Feed = propertyValue as AtomFeed;
property.Entry = propertyValue as AtomEntry;
}
targetEntry.DataValues.Add(property);
}
}
/// <summary>Consumes the next chunk of content from the underlying XML reader.</summary>
/// <returns>
/// true if another piece of content is available, identified by DataKind.
/// false if there is no more content.
/// </returns>
internal bool Read()
{
// When an external caller 'insists', we'll come all the way down (which is the 'most local'
// scope at which this is known), and unwind as a no-op.
if (this.DataKind == AtomDataKind.Finished)
{
return(false);
}
while (this.reader.Read())
{
if (ShouldIgnoreNode(this.reader))
{
continue;
}
Debug.Assert(
this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement,
"this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement -- otherwise we should have ignored or thrown");
AtomDataKind readerData = ParseStateForReader(this.reader);
if (this.reader.NodeType == XmlNodeType.EndElement)
{
// The only case in which we expect to see an end-element at the top level
// is for a feed. Custom elements and entries should be consumed by
// their own parsing methods. However we are tolerant of additional EndElements,
// which at this point mean we have nothing else to consume.
break;
}
switch (readerData)
{
case AtomDataKind.Custom:
if (this.DataKind == AtomDataKind.None)
{
this.kind = AtomDataKind.Custom;
return(true);
}
else
{
MaterializeAtom.SkipToEnd(this.reader);
continue;
}
case AtomDataKind.Entry:
this.kind = AtomDataKind.Entry;
this.ParseCurrentEntry(out this.entry);
return(true);
case AtomDataKind.Feed:
if (this.DataKind == AtomDataKind.None)
{
this.feed = new AtomFeed();
this.kind = AtomDataKind.Feed;
return(true);
}
throw new InvalidOperationException(Strings.AtomParser_FeedUnexpected);
case AtomDataKind.FeedCount:
this.ParseCurrentFeedCount();
break;
case AtomDataKind.PagingLinks:
if (this.feed == null)
{
// paging link outside of feed?
throw new InvalidOperationException(Strings.AtomParser_PagingLinkOutsideOfFeed);
}
this.kind = AtomDataKind.PagingLinks;
this.ParseCurrentFeedPagingLinks();
return(true);
default:
Debug.Assert(false, "Atom Parser is in a wrong state...Did you add a new AtomDataKind?");
break;
}
}
this.kind = AtomDataKind.Finished;
this.entry = null;
return(false);
}