/// <summary> /// Writes the 'atom:category' element given category metadata. /// </summary> /// <param name="category">The category information to write.</param> internal void WriteCategory(AtomCategoryMetadata category) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(category != null, "Category must not be null."); this.WriteCategory(AtomConstants.AtomNamespacePrefix, category.Term, category.Scheme, category.Label); }
internal static AtomCategoryMetadata MergeCategoryMetadata(AtomCategoryMetadata categoryMetadata, string term, string scheme) { AtomCategoryMetadata metadata = new AtomCategoryMetadata(categoryMetadata); string strB = metadata.Term; if (strB != null) { if (string.CompareOrdinal(term, strB) != 0) { throw new ODataException(Strings.ODataAtomWriterMetadataUtils_CategoryTermsMustMatch(term, strB)); } } else { metadata.Term = term; } string str2 = metadata.Scheme; if (str2 == null) { metadata.Scheme = scheme; return(metadata); } if (string.CompareOrdinal(scheme, str2) != 0) { throw new ODataException(Strings.ODataAtomWriterMetadataUtils_CategorySchemesMustMatch(scheme, str2)); } return(metadata); }
/// <summary> /// Reads an "atom:category" element and returns the data as an <seealso cref="AtomCategoryMetadata"/> object. /// </summary> /// <returns>An <seealso cref="AtomCategoryMetadata"/> object with its properties filled in according to what was found in the XML.</returns> /// <remarks> /// Pre-Condition: XmlNodeType.Element - The start of the atom:category element. /// Post-Condition: Any - The next node after the atom:category element. /// </remarks> private AtomCategoryMetadata ReadCategoryElementInCollection() { this.AssertXmlCondition(XmlNodeType.Element); Debug.Assert(this.XmlReader.LocalName == AtomConstants.AtomCategoryElementName, "Expected element named 'category'."); Debug.Assert(this.XmlReader.NamespaceURI == AtomConstants.AtomNamespace, "Element 'category' should be in the atom namespace."); AtomCategoryMetadata categoryMetadata = new AtomCategoryMetadata(); while (this.XmlReader.MoveToNextAttribute()) { string attributeValue = this.XmlReader.Value; if (this.XmlReader.NamespaceEquals(this.EmptyNamespace)) { if (this.XmlReader.LocalNameEquals(this.AtomCategoryTermAttributeName)) { categoryMetadata.Term = attributeValue; } else if (this.XmlReader.LocalNameEquals(this.AtomCategorySchemeAttributeName)) { categoryMetadata.Scheme = attributeValue; } else if (this.XmlReader.LocalNameEquals(this.AtomCategoryLabelAttributeName)) { categoryMetadata.Label = attributeValue; } } } return(categoryMetadata); }
private void ReadCategoryElement(AtomFeedMetadata atomFeedMetadata) { AtomCategoryMetadata categoryMetadata = new AtomCategoryMetadata(); while (base.XmlReader.MoveToNextAttribute()) { string str; if (base.XmlReader.NamespaceEquals(this.EmptyNamespace) && ((str = base.XmlReader.LocalName) != null)) { if (!(str == "scheme")) { if (str == "term") { goto Label_0069; } if (str == "label") { goto Label_007C; } } else { categoryMetadata.Scheme = base.XmlReader.Value; } } continue; Label_0069: categoryMetadata.Term = base.XmlReader.Value; continue; Label_007C: categoryMetadata.Label = base.XmlReader.Value; } AtomMetadataReaderUtils.AddCategoryToFeedMetadata(atomFeedMetadata, categoryMetadata); base.XmlReader.Skip(); }
private AtomCategoryMetadata ReadCategoryElementInCollection() { AtomCategoryMetadata metadata = new AtomCategoryMetadata(); while (base.XmlReader.MoveToNextAttribute()) { string str = base.XmlReader.Value; if (base.XmlReader.NamespaceEquals(this.EmptyNamespace)) { if (base.XmlReader.LocalNameEquals(this.AtomCategoryTermAttributeName)) { metadata.Term = str; } else { if (base.XmlReader.LocalNameEquals(this.AtomCategorySchemeAttributeName)) { metadata.Scheme = str; continue; } if (base.XmlReader.LocalNameEquals(this.AtomCategoryLabelAttributeName)) { metadata.Label = str; } } } } return(metadata); }
internal static AtomCategoryMetadata MergeCategoryMetadata(AtomCategoryMetadata categoryMetadata, string term, string scheme) { AtomCategoryMetadata metadata = new AtomCategoryMetadata(categoryMetadata); string strB = metadata.Term; if (strB != null) { if (string.CompareOrdinal(term, strB) != 0) { throw new ODataException(Strings.ODataAtomWriterMetadataUtils_CategoryTermsMustMatch(term, strB)); } } else { metadata.Term = term; } string str2 = metadata.Scheme; if (str2 == null) { metadata.Scheme = scheme; return metadata; } if (string.CompareOrdinal(scheme, str2) != 0) { throw new ODataException(Strings.ODataAtomWriterMetadataUtils_CategorySchemesMustMatch(scheme, str2)); } return metadata; }
internal AtomCategoryMetadata ReadAtomCategoryElement() { AtomCategoryMetadata metadata = new AtomCategoryMetadata(); while (base.XmlReader.MoveToNextAttribute()) { string str2; if (!base.XmlReader.NamespaceEquals(this.EmptyNamespace)) { goto Label_00AF; } string localName = base.XmlReader.LocalName; if (localName != null) { if (!(localName == "scheme")) { if (localName == "term") { goto Label_007F; } if (localName == "label") { goto Label_009C; } } else { metadata.Scheme = metadata.Scheme ?? base.XmlReader.Value; } } continue; Label_007F :; metadata.Term = metadata.Term ?? base.XmlReader.Value; continue; Label_009C: metadata.Label = base.XmlReader.Value; continue; Label_00AF: if ((base.UseClientFormatBehavior && base.XmlReader.NamespaceEquals(this.AtomNamespace)) && ((str2 = base.XmlReader.LocalName) != null)) { if (!(str2 == "scheme")) { if (str2 == "term") { goto Label_0108; } } else { metadata.Scheme = base.XmlReader.Value; } } continue; Label_0108: metadata.Term = base.XmlReader.Value; } base.XmlReader.Skip(); return(metadata); }
internal static void AddCategoryToFeedMetadata(AtomFeedMetadata feedMetadata, AtomCategoryMetadata categoryMetadata) { if (object.ReferenceEquals(feedMetadata.Categories, EmptyCategoriesList)) { feedMetadata.Categories = new ReadOnlyEnumerable<AtomCategoryMetadata>(); } ReaderUtils.GetSourceListOfEnumerable<AtomCategoryMetadata>(feedMetadata.Categories, "Categories").Add(categoryMetadata); }
internal void WriteEntryTypeName(string typeName, AtomEntryMetadata entryMetadata) { if (typeName != null) { AtomCategoryMetadata category = ODataAtomWriterMetadataUtils.MergeCategoryMetadata((entryMetadata == null) ? null : entryMetadata.CategoryWithTypeName, typeName, base.MessageWriterSettings.WriterBehavior.ODataTypeScheme); this.atomEntryMetadataSerializer.WriteCategory(category); } }
internal AtomCategoryMetadata ReadAtomCategoryElement() { AtomCategoryMetadata metadata = new AtomCategoryMetadata(); while (base.XmlReader.MoveToNextAttribute()) { string str2; if (!base.XmlReader.NamespaceEquals(this.EmptyNamespace)) { goto Label_00AF; } string localName = base.XmlReader.LocalName; if (localName != null) { if (!(localName == "scheme")) { if (localName == "term") { goto Label_007F; } if (localName == "label") { goto Label_009C; } } else { metadata.Scheme = metadata.Scheme ?? base.XmlReader.Value; } } continue; Label_007F:; metadata.Term = metadata.Term ?? base.XmlReader.Value; continue; Label_009C: metadata.Label = base.XmlReader.Value; continue; Label_00AF: if ((base.UseClientFormatBehavior && base.XmlReader.NamespaceEquals(this.AtomNamespace)) && ((str2 = base.XmlReader.LocalName) != null)) { if (!(str2 == "scheme")) { if (str2 == "term") { goto Label_0108; } } else { metadata.Scheme = base.XmlReader.Value; } } continue; Label_0108: metadata.Term = base.XmlReader.Value; } base.XmlReader.Skip(); return metadata; }
/// <summary> /// Reads the atom:category element. /// </summary> /// <returns>The ATOM category metadata read.</returns> /// <remarks> /// Pre-Condition: XmlNodeType.Element (atom:category) - the atom:category element to read. /// Post-Condition: Any - the node after the atom:category which was read. /// </remarks> internal AtomCategoryMetadata ReadAtomCategoryElement() { DebugUtils.CheckNoExternalCallers(); this.AssertXmlCondition(XmlNodeType.Element); Debug.Assert( this.XmlReader.NamespaceURI == AtomConstants.AtomNamespace && this.XmlReader.LocalName == AtomConstants.AtomCategoryElementName, "Only atom:category element can be read by this method."); AtomCategoryMetadata categoryMetadata = new AtomCategoryMetadata(); // Read the attributes while (this.XmlReader.MoveToNextAttribute()) { if (this.XmlReader.NamespaceEquals(this.EmptyNamespace)) { switch (this.XmlReader.LocalName) { case AtomConstants.AtomCategorySchemeAttributeName: categoryMetadata.Scheme = categoryMetadata.Scheme ?? this.XmlReader.Value; break; case AtomConstants.AtomCategoryTermAttributeName: categoryMetadata.Term = categoryMetadata.Term ?? this.XmlReader.Value; break; case AtomConstants.AtomCategoryLabelAttributeName: categoryMetadata.Label = this.XmlReader.Value; break; default: // Ignore all other attributes. break; } } else if (this.UseClientFormatBehavior && this.XmlReader.NamespaceEquals(this.AtomNamespace)) { switch (this.XmlReader.LocalName) { case AtomConstants.AtomCategorySchemeAttributeName: categoryMetadata.Scheme = this.XmlReader.Value; break; case AtomConstants.AtomCategoryTermAttributeName: categoryMetadata.Term = this.XmlReader.Value; break; default: // Ignore all other attributes. break; } } } // Skip the element in any case (we only ever consume attributes on it anyway). this.XmlReader.Skip(); return(categoryMetadata); }
internal AtomCategoryMetadata(AtomCategoryMetadata other) { if (other != null) { this.Term = other.Term; this.Scheme = other.Scheme; this.Label = other.Label; } }
/// <summary> /// Writes the type name category element for the entry. /// </summary> /// <param name="typeName">The type name to write.</param> /// <param name="entryMetadata">The entry metadata if available.</param> internal void WriteEntryTypeName(string typeName, AtomEntryMetadata entryMetadata) { DebugUtils.CheckNoExternalCallers(); if (typeName != null) { AtomCategoryMetadata mergedCategoryMetadata = ODataAtomWriterMetadataUtils.MergeCategoryMetadata( entryMetadata == null ? null : entryMetadata.CategoryWithTypeName, typeName, this.MessageWriterSettings.WriterBehavior.ODataTypeScheme); this.atomEntryMetadataSerializer.WriteCategory(mergedCategoryMetadata); } }
/// <summary> /// Creates a new <see cref="AtomCategoryMetadata"/> instance by merging the given /// <paramref name="categoryMetadata"/> (if any) with the specified <paramref name="term"/> and <paramref name="scheme"/>. /// </summary> /// <param name="categoryMetadata">The metadata to merge with the <paramref name="term"/> and <paramref name="scheme"/>.</param> /// <param name="term">The term to use in the merged metadata.</param> /// <param name="scheme">The scheme to use in the merged metadata.</param> /// <returns>A new <see cref="AtomCategoryMetadata"/> instance created by merging all the arguments.</returns> /// <remarks> /// If the <paramref name="categoryMetadata"/> already holds values for <paramref name="term"/> or <paramref name="scheme"/> /// this method validates that they are the same as the ones specified in the method arguments. /// </remarks> internal static AtomCategoryMetadata MergeCategoryMetadata(AtomCategoryMetadata categoryMetadata, string term, string scheme) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(term != null, "term != null"); Debug.Assert(scheme != null, "scheme != null"); AtomCategoryMetadata mergedCategoryMetadata = new AtomCategoryMetadata(categoryMetadata); // Set the term. string metadataTerm = mergedCategoryMetadata.Term; if (metadataTerm != null) { // Validate that terms are the same. if (string.CompareOrdinal(term, metadataTerm) != 0) { throw new ODataException(Strings.ODataAtomWriterMetadataUtils_CategoryTermsMustMatch(term, metadataTerm)); } } else { mergedCategoryMetadata.Term = term; } // Set the scheme. string metadataScheme = mergedCategoryMetadata.Scheme; if (metadataScheme != null) { // Validate that schemes are the same. if (string.CompareOrdinal(scheme, metadataScheme) != 0) { throw new ODataException(Strings.ODataAtomWriterMetadataUtils_CategorySchemesMustMatch(scheme, metadataScheme)); } } else { mergedCategoryMetadata.Scheme = scheme; } return(mergedCategoryMetadata); }
/// <summary> /// Reads an atom:category element in a feed. /// </summary> /// <param name="atomFeedMetadata">The feed metadata to augment.</param> /// <remarks> /// Pre-Condition: XmlNodeType.Element (atom:category) - the atom:category element to read. /// Post-Condition: Any - the node after the atom:category which was read. /// </remarks> private void ReadCategoryElement(AtomFeedMetadata atomFeedMetadata) { DebugUtils.CheckNoExternalCallers(); this.AssertXmlCondition(XmlNodeType.Element); Debug.Assert( this.XmlReader.NamespaceURI == AtomConstants.AtomNamespace && this.XmlReader.LocalName == AtomConstants.AtomCategoryElementName, "Only atom:category element can be read by this method."); AtomCategoryMetadata categoryMetadata = new AtomCategoryMetadata(); // Read the attributes while (this.XmlReader.MoveToNextAttribute()) { if (this.XmlReader.NamespaceEquals(this.EmptyNamespace)) { switch (this.XmlReader.LocalName) { case AtomConstants.AtomCategorySchemeAttributeName: categoryMetadata.Scheme = this.XmlReader.Value; break; case AtomConstants.AtomCategoryTermAttributeName: categoryMetadata.Term = this.XmlReader.Value; break; case AtomConstants.AtomCategoryLabelAttributeName: categoryMetadata.Label = this.XmlReader.Value; break; default: // Ignore all other attributes. break; } } } atomFeedMetadata.AddCategory(categoryMetadata); // Skip the rest of the category element. this.XmlReader.Skip(); }
/// <summary> /// Reads the atom:category element in the entry content. /// </summary> /// <param name="entryState">The reader entry state for the entry being read.</param> /// <remarks> /// Pre-Condition: XmlNodeType.Element (atom:category) - the atom:category element to read. /// Post-Condition: Any - the node after the atom:category which was read. /// </remarks> internal void ReadAtomCategoryElementInEntryContent(IODataAtomReaderEntryState entryState) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(entryState != null, "entryState != null"); this.AssertXmlCondition(XmlNodeType.Element); Debug.Assert( this.XmlReader.NamespaceURI == AtomConstants.AtomNamespace && this.XmlReader.LocalName == AtomConstants.AtomCategoryElementName, "Only atom:category element can be read by this method."); ODataEntityPropertyMappingCache cachedEpm = entryState.CachedEpm; EpmTargetPathSegment epmTargetPathSegment = null; if (cachedEpm != null) { epmTargetPathSegment = cachedEpm.EpmTargetTree.SyndicationRoot; } // Rough estimate if we will need the category for EPM - we can't tell for sure since we don't know the scheme value yet. bool hasCategoryEpm = epmTargetPathSegment != null && epmTargetPathSegment.SubSegments.Any(segment => string.CompareOrdinal(segment.SegmentName, AtomConstants.AtomCategoryElementName) == 0); // Read the attributes and create the category metadata regardless if we will need it or not. // We can do this since there's no validation done on any of the values and thus this operation will never fail. // If we then decide we don't need it, we can safely throw it away. if (this.ReadAtomMetadata || hasCategoryEpm) { AtomCategoryMetadata categoryMetadata = this.ReadAtomCategoryElement(); // No point in trying to figure out if we will need the category for EPM or not here. // Our EPM syndication reader must handle unneeded categories anyway (if ATOM metadata reading is on) // So instead of burning the cycles to compute if we need it, just store it anyway. AtomMetadataReaderUtils.AddCategoryToEntryMetadata(entryState.AtomEntryMetadata, categoryMetadata); } else { // Skip the element in any case (we only ever consume attributes on it anyway). this.XmlReader.Skip(); } }
internal void ReadAtomCategoryElementInEntryContent(IODataAtomReaderEntryState entryState) { ODataEntityPropertyMappingCache cachedEpm = entryState.CachedEpm; EpmTargetPathSegment syndicationRoot = null; if (cachedEpm != null) { syndicationRoot = cachedEpm.EpmTargetTree.SyndicationRoot; } if (syndicationRoot == null) { } bool flag = syndicationRoot.SubSegments.Any <EpmTargetPathSegment>(); if (base.ReadAtomMetadata || flag) { AtomCategoryMetadata categoryMetadata = this.ReadAtomCategoryElement(); AtomMetadataReaderUtils.AddCategoryToEntryMetadata(entryState.AtomEntryMetadata, categoryMetadata); } else { base.XmlReader.Skip(); } }
/// <summary> /// Reads an atom:category element in a feed. /// </summary> /// <param name="atomFeedMetadata">The feed metadata to augment.</param> /// <remarks> /// Pre-Condition: XmlNodeType.Element (atom:category) - the atom:category element to read. /// Post-Condition: Any - the node after the atom:category which was read. /// </remarks> private void ReadCategoryElement(AtomFeedMetadata atomFeedMetadata) { DebugUtils.CheckNoExternalCallers(); this.AssertXmlCondition(XmlNodeType.Element); Debug.Assert( this.XmlReader.NamespaceURI == AtomConstants.AtomNamespace && this.XmlReader.LocalName == AtomConstants.AtomCategoryElementName, "Only atom:category element can be read by this method."); AtomCategoryMetadata categoryMetadata = new AtomCategoryMetadata(); // Read the attributes while (this.XmlReader.MoveToNextAttribute()) { if (this.XmlReader.NamespaceEquals(this.EmptyNamespace)) { switch (this.XmlReader.LocalName) { case AtomConstants.AtomCategorySchemeAttributeName: categoryMetadata.Scheme = this.XmlReader.Value; break; case AtomConstants.AtomCategoryTermAttributeName: categoryMetadata.Term = this.XmlReader.Value; break; case AtomConstants.AtomCategoryLabelAttributeName: categoryMetadata.Label = this.XmlReader.Value; break; default: // Ignore all other attributes. break; } } } AtomMetadataReaderUtils.AddCategoryToFeedMetadata(atomFeedMetadata, categoryMetadata); // Skip the rest of the category element. this.XmlReader.Skip(); }
private AtomCategoryMetadata ReadCategoryElementInCollection() { AtomCategoryMetadata metadata = new AtomCategoryMetadata(); while (base.XmlReader.MoveToNextAttribute()) { string str = base.XmlReader.Value; if (base.XmlReader.NamespaceEquals(this.EmptyNamespace)) { if (base.XmlReader.LocalNameEquals(this.AtomCategoryTermAttributeName)) { metadata.Term = str; } else { if (base.XmlReader.LocalNameEquals(this.AtomCategorySchemeAttributeName)) { metadata.Scheme = str; continue; } if (base.XmlReader.LocalNameEquals(this.AtomCategoryLabelAttributeName)) { metadata.Label = str; } } } } return metadata; }
/// <summary> /// Creates a new <see cref="AtomCategoryMetadata"/> instance by merging the given /// <paramref name="categoryMetadata"/> (if any) with the specified <paramref name="term"/> and <paramref name="scheme"/>. /// </summary> /// <param name="categoryMetadata">The metadata to merge with the <paramref name="term"/> and <paramref name="scheme"/>.</param> /// <param name="term">The term to use in the merged metadata.</param> /// <param name="scheme">The scheme to use in the merged metadata.</param> /// <returns>A new <see cref="AtomCategoryMetadata"/> instance created by merging all the arguments.</returns> /// <remarks> /// If the <paramref name="categoryMetadata"/> already holds values for <paramref name="term"/> or <paramref name="scheme"/> /// this method validates that they are the same as the ones specified in the method arguments. /// </remarks> internal static AtomCategoryMetadata MergeCategoryMetadata(AtomCategoryMetadata categoryMetadata, string term, string scheme) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(term != null, "term != null"); Debug.Assert(scheme != null, "scheme != null"); AtomCategoryMetadata mergedCategoryMetadata = new AtomCategoryMetadata(categoryMetadata); // Set the term. string metadataTerm = mergedCategoryMetadata.Term; if (metadataTerm != null) { // Validate that terms are the same. if (string.CompareOrdinal(term, metadataTerm) != 0) { throw new ODataException(Strings.ODataAtomWriterMetadataUtils_CategoryTermsMustMatch(term, metadataTerm)); } } else { mergedCategoryMetadata.Term = term; } // Set the scheme. string metadataScheme = mergedCategoryMetadata.Scheme; if (metadataScheme != null) { // Validate that schemes are the same. if (string.CompareOrdinal(scheme, metadataScheme) != 0) { throw new ODataException(Strings.ODataAtomWriterMetadataUtils_CategorySchemesMustMatch(scheme, metadataScheme)); } } else { mergedCategoryMetadata.Scheme = scheme; } return mergedCategoryMetadata; }
/// <summary> /// Reads an "atom:category" element and returns the data as an <seealso cref="AtomCategoryMetadata"/> object. /// </summary> /// <returns>An <seealso cref="AtomCategoryMetadata"/> object with its properties filled in according to what was found in the XML.</returns> /// <remarks> /// Pre-Condition: XmlNodeType.Element - The start of the atom:category element. /// Post-Condition: Any - The next node after the atom:category element. /// </remarks> private AtomCategoryMetadata ReadCategoryElementInCollection() { this.AssertXmlCondition(XmlNodeType.Element); Debug.Assert(this.XmlReader.LocalName == AtomConstants.AtomCategoryElementName, "Expected element named 'category'."); Debug.Assert(this.XmlReader.NamespaceURI == AtomConstants.AtomNamespace, "Element 'category' should be in the atom namespace."); AtomCategoryMetadata categoryMetadata = new AtomCategoryMetadata(); while (this.XmlReader.MoveToNextAttribute()) { string attributeValue = this.XmlReader.Value; if (this.XmlReader.NamespaceEquals(this.EmptyNamespace)) { if (this.XmlReader.LocalNameEquals(this.AtomCategoryTermAttributeName)) { categoryMetadata.Term = attributeValue; } else if (this.XmlReader.LocalNameEquals(this.AtomCategorySchemeAttributeName)) { categoryMetadata.Scheme = attributeValue; } else if (this.XmlReader.LocalNameEquals(this.AtomCategoryLabelAttributeName)) { categoryMetadata.Label = attributeValue; } } } return categoryMetadata; }
internal void WriteCategory(AtomCategoryMetadata category) { this.WriteCategory("", category.Term, category.Scheme, category.Label); }
/// <summary> /// Adds a new category to feed metadata. /// </summary> /// <param name="feedMetadata">The feed metadata to add the category to.</param> /// <param name="categoryMetadata">The category metadata to add.</param> internal static void AddCategoryToFeedMetadata(AtomFeedMetadata feedMetadata, AtomCategoryMetadata categoryMetadata) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(feedMetadata != null, "feedMetadata != null"); Debug.Assert(categoryMetadata != null, "categoryMetadata != null"); if (object.ReferenceEquals(feedMetadata.Categories, EmptyCategoriesList)) { feedMetadata.Categories = new ReadOnlyEnumerable<AtomCategoryMetadata>(); } ReaderUtils.GetSourceListOfEnumerable(feedMetadata.Categories, "Categories").Add(categoryMetadata); }
/// <summary> /// Reads the atom:category element. /// </summary> /// <returns>The ATOM category metadata read.</returns> /// <remarks> /// Pre-Condition: XmlNodeType.Element (atom:category) - the atom:category element to read. /// Post-Condition: Any - the node after the atom:category which was read. /// </remarks> internal AtomCategoryMetadata ReadAtomCategoryElement() { DebugUtils.CheckNoExternalCallers(); this.AssertXmlCondition(XmlNodeType.Element); Debug.Assert( this.XmlReader.NamespaceURI == AtomConstants.AtomNamespace && this.XmlReader.LocalName == AtomConstants.AtomCategoryElementName, "Only atom:category element can be read by this method."); AtomCategoryMetadata categoryMetadata = new AtomCategoryMetadata(); // Read the attributes while (this.XmlReader.MoveToNextAttribute()) { if (this.XmlReader.NamespaceEquals(this.EmptyNamespace)) { switch (this.XmlReader.LocalName) { case AtomConstants.AtomCategorySchemeAttributeName: categoryMetadata.Scheme = categoryMetadata.Scheme ?? this.XmlReader.Value; break; case AtomConstants.AtomCategoryTermAttributeName: categoryMetadata.Term = categoryMetadata.Term ?? this.XmlReader.Value; break; case AtomConstants.AtomCategoryLabelAttributeName: categoryMetadata.Label = this.XmlReader.Value; break; default: // Ignore all other attributes. break; } } else if (this.UseClientFormatBehavior && this.XmlReader.NamespaceEquals(this.AtomNamespace)) { switch (this.XmlReader.LocalName) { case AtomConstants.AtomCategorySchemeAttributeName: categoryMetadata.Scheme = this.XmlReader.Value; break; case AtomConstants.AtomCategoryTermAttributeName: categoryMetadata.Term = this.XmlReader.Value; break; default: // Ignore all other attributes. break; } } } // Skip the element in any case (we only ever consume attributes on it anyway). this.XmlReader.Skip(); return categoryMetadata; }