#pragma warning restore 649
#endif
#endregion Private fields.
internal MaterializeAtom(DataServiceContext context, XmlReader reader, QueryComponents queryComponents, ProjectionPlan plan, MergeOption mergeOption)
{
Debug.Assert(queryComponents != null, "queryComponents != null");
this.context = context;
this.elementType = queryComponents.LastSegmentType;
this.MergeOptionValue = mergeOption;
this.ignoreMissingProperties = context.IgnoreMissingProperties;
this.reader = (reader == null) ? null : new System.Data.Services.Client.Xml.XmlAtomErrorReader(reader);
this.countValue = CountStateInitial;
this.expectingSingleValue = ClientConvert.IsKnownNullableType(elementType);
Debug.Assert(reader != null, "Materializer reader is null! Did you mean to use Materializer.ResultsWrapper/EmptyResults?");
reader.Settings.NameTable.Add(context.DataNamespace);
string typeScheme = this.context.TypeScheme.OriginalString;
this.parser = new AtomParser(this.reader, AtomParser.XElementBuilderCallback, typeScheme, context.DataNamespace);
AtomMaterializerLog log = new AtomMaterializerLog(this.context, mergeOption);
Type implementationType;
Type materializerType = GetTypeForMaterializer(this.expectingSingleValue, this.elementType, out implementationType);
this.materializer = new AtomMaterializer(parser, context, materializerType, this.ignoreMissingProperties, mergeOption, log, this.MaterializedObjectCallback, queryComponents, plan);
}
#pragma warning restore 649
#endif
#endregion Private fields.
/// <summary>
/// constructor
/// </summary>
/// <param name="context">originating context</param>
/// <param name="reader">reader</param>
/// <param name="queryComponents">Query components (projection, expected type)</param>
/// <param name="plan">Projection plan (if compiled in an earlier query).</param>
/// <param name="mergeOption">merge option to use for this materialization pass</param>
internal MaterializeAtom(DataServiceContext context, XmlReader reader, QueryComponents queryComponents, ProjectionPlan plan, MergeOption mergeOption)
{
Debug.Assert(queryComponents != null, "queryComponents != null");
this.context = context;
this.elementType = queryComponents.LastSegmentType;
this.MergeOptionValue = mergeOption;
this.ignoreMissingProperties = context.IgnoreMissingProperties;
this.reader = (reader == null) ? null : new System.Data.Services.Client.Xml.XmlAtomErrorReader(reader);
this.countValue = CountStateInitial;
this.expectingSingleValue = ClientConvert.IsKnownNullableType(elementType);
Debug.Assert(reader != null, "Materializer reader is null! Did you mean to use Materializer.ResultsWrapper/EmptyResults?");
// NOTE: dataNamespace is used for reference equality, and while it looks like
// a variable, it appears that it will only get set to XmlConstants.DataWebNamespace
// at runtime. Therefore we remove string dataNamespace as a field here.
// this.dataNamespace = reader != null ? reader.Settings.NameTable.Add(context.DataNamespace) : null;
reader.Settings.NameTable.Add(context.DataNamespace);
string typeScheme = this.context.TypeScheme.OriginalString;
this.parser = new AtomParser(this.reader, AtomParser.XElementBuilderCallback, typeScheme, context.DataNamespace);
AtomMaterializerLog log = new AtomMaterializerLog(this.context, mergeOption);
Type implementationType;
Type materializerType = GetTypeForMaterializer(this.expectingSingleValue, this.elementType, out implementationType);
this.materializer = new AtomMaterializer(parser, context, materializerType, this.ignoreMissingProperties, mergeOption, log, this.MaterializedObjectCallback, queryComponents, plan);
}
/// <summary>
/// Parses the content on the reader into the specified <paramref name="targetEntry"/>.
/// </summary>
/// <param name="targetEntry">Target to read values into.</param>
private void ParseCurrentContent(AtomEntry targetEntry)
{
Debug.Assert(targetEntry != null, "targetEntry != null");
Debug.Assert(this.reader.NodeType == XmlNodeType.Element, "this.reader.NodeType == XmlNodeType.Element");
string propertyValue = this.reader.GetAttributeEx(XmlConstants.AtomContentSrcAttributeName, XmlConstants.AtomNamespace);
if (propertyValue != null)
{
// This is a media link entry
// Note that in this case we don't actually use this URL (or the link/edit-media URL)
// for editing. We rely on the Astoria URL convention (/propname/$value or just /$value)
if (!this.reader.IsEmptyElement)
{
throw Error.InvalidOperation(Strings.Deserialize_ExpectedEmptyMediaLinkEntryContent);
}
targetEntry.MediaLinkEntry = true;
targetEntry.MediaContentUri = new Uri(propertyValue, UriKind.RelativeOrAbsolute);
}
else
{
// This is a regular (non-media link) entry
if (targetEntry.MediaLinkEntry.HasValue && targetEntry.MediaLinkEntry.Value)
{
// This means we saw a <m:Properties> element but now we have a Content element
// that's not just a media link entry pointer (src)
throw Error.InvalidOperation(Strings.Deserialize_ContentPlusPropertiesNotAllowed);
}
targetEntry.MediaLinkEntry = false;
propertyValue = this.reader.GetAttributeEx(XmlConstants.AtomTypeAttributeName, XmlConstants.AtomNamespace);
if (AtomParser.IsAllowedContentType(propertyValue))
{
if (this.reader.IsEmptyElement)
{
return;
}
if (ReadChildElement(this.reader, XmlConstants.AtomPropertiesElementName, XmlConstants.DataWebMetadataNamespace))
{
this.ReadCurrentProperties(targetEntry.DataValues);
}
else if (this.reader.NodeType != XmlNodeType.EndElement)
{
throw Error.InvalidOperation(Strings.Deserialize_NotApplicationXml);
}
}
}
}
private void ParseCurrentContent(AtomEntry targetEntry)
{
Debug.Assert(targetEntry != null, "targetEntry != null");
Debug.Assert(this.reader.NodeType == XmlNodeType.Element, "this.reader.NodeType == XmlNodeType.Element");
string propertyValue = this.reader.GetAttributeEx(XmlConstants.AtomContentSrcAttributeName, XmlConstants.AtomNamespace);
if (propertyValue != null)
{
if (!this.reader.IsEmptyElement)
{
throw Error.InvalidOperation(Strings.Deserialize_ExpectedEmptyMediaLinkEntryContent);
}
targetEntry.MediaLinkEntry = true;
targetEntry.MediaContentUri = new Uri(propertyValue, UriKind.RelativeOrAbsolute);
}
else
{
if (targetEntry.MediaLinkEntry.HasValue && targetEntry.MediaLinkEntry.Value)
{
throw Error.InvalidOperation(Strings.Deserialize_ContentPlusPropertiesNotAllowed);
}
targetEntry.MediaLinkEntry = false;
propertyValue = this.reader.GetAttributeEx(XmlConstants.AtomTypeAttributeName, XmlConstants.AtomNamespace);
if (AtomParser.IsAllowedContentType(propertyValue))
{
if (this.reader.IsEmptyElement)
{
return;
}
if (ReadChildElement(this.reader, XmlConstants.AtomPropertiesElementName, XmlConstants.DataWebMetadataNamespace))
{
this.ReadCurrentProperties(targetEntry.DataValues);
}
else
if (this.reader.NodeType != XmlNodeType.EndElement)
{
throw Error.InvalidOperation(Strings.Deserialize_NotApplicationXml);
}
}
}
}
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)
{
// Only process the first link that has @rel='edit'.
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)
{
// Only process the first link that has @rel='self'.
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:
// Here the inner feed parser found a paging link, and stored it on nestedFeed.NextPageLink
// we are going to add it into a link table and associate
// with the collection at AtomMaterializer::Materialize()
// Do nothing for now.
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);
}
}
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);
}
}
