|
public GetNamespacesInScope ( XmlNamespaceScope scope ) : string>.IDictionary |
||
| scope | XmlNamespaceScope | |
| return | string>.IDictionary | |
public BindingExpressionContext(BaseParser parser, XPathNavigator boundNode, IDictionary<string, string> inScopeNamespaces)
{
this.Parser = parser;
this.BoundNode = boundNode;
if (inScopeNamespaces == null) {
inScopeNamespaces = boundNode.GetNamespacesInScope(XmlNamespaceScope.All);
}
this._InScopeNamespaces = inScopeNamespaces;
}
/// <summary>
/// Determines if the <see cref="SyndicationExtension"/> exists in the XML data in the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to parse.</param>
/// <returns><b>true</b> if the <see cref="SyndicationExtension"/> elements or attributes are present in the <paramref name="source"/>; otherwise <b>false</b>.</returns>
/// <remarks>
/// <para>
/// This method should be as lightweight as possible when determining if the <see cref="SyndicationExtension"/> or its related entities are present in the <paramref name="source"/>.
/// The default implementation utilizes the <see cref="XPathNavigator.GetNamespacesInScope(XmlNamespaceScope)"/> method to determine if the <paramref name="source"/> contains
/// the expected namespace(s) for this <see cref="SyndicationExtension"/>.
/// </para>
/// <para>It is recommended that you call this method prior to executing a possibly costly load operation using the <see cref="SyndicationExtension.Load(IXPathNavigable)"/> method.</para>
/// </remarks>
public virtual bool ExistsInSource(XPathNavigator source)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool extensionExists = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
//------------------------------------------------------------
// Determine if extension exists
//------------------------------------------------------------
Dictionary<string, string> namespaces = (Dictionary<string, string>)source.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
if (namespaces.ContainsValue(this.XmlNamespace))
{
extensionExists = true;
}
else if (namespaces.ContainsKey(this.XmlPrefix))
{
extensionExists = true;
}
return extensionExists;
}
/// <summary>
/// Initializes a <see cref="XmlNamespaceManager"/> object for resolving prefixed XML namespaces utilized by this <see cref="SyndicationExtension"/>.
/// </summary>
/// <param name="navigator">Provides a cursor model for navigating syndication extension data.</param>
/// <returns>A <see cref="XmlNamespaceManager"/> that resolves prefixed XML namespaces and provides scope management for these namespaces.</returns>
/// <remarks>
/// This method will return a <see cref="XmlNamespaceManager"/> that has a namespace added to it using the <see cref="XmlPrefix"/> and <see cref="XmlNamespace"/>
/// of the extension unless the supplied <see cref="XPathNavigator"/> already has an XML namespace associated to the <see cref="XmlPrefix"/>, in which case
/// the associated XML namespace is used instead. This is to prevent collisions and is an attempt to gracefully handle the case where a XML namespace that
/// is not per the extension's specification has been declared on the syndication resource.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
public XmlNamespaceManager CreateNamespaceManager(XPathNavigator navigator)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
XmlNamespaceManager manager = null;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(navigator, "navigator");
//------------------------------------------------------------
// Initialize XML namespace resolver
//------------------------------------------------------------
manager = new XmlNamespaceManager(navigator.NameTable);
Dictionary<string, string> namespaces = (Dictionary<string, string>)navigator.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
string existingXmlNamespace = String.Empty;
if (namespaces.ContainsKey(this.XmlPrefix))
{
existingXmlNamespace = namespaces[this.XmlPrefix];
}
manager.AddNamespace(this.XmlPrefix, !String.IsNullOrEmpty(existingXmlNamespace) ? existingXmlNamespace : this.XmlNamespace);
return manager;
}
private static void NormalizeNamespaces(XPathNavigator src, XPathNavigator dest) {
IDictionary<string, string> dictLocal = src.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
IDictionary<string, string> dictExclude = dest.GetNamespacesInScope(XmlNamespaceScope.Local);
foreach(KeyValuePair<string, string> pair in dictLocal)
if(!dictExclude.ContainsKey(pair.Key))
dest.CreateAttribute("xmlns", pair.Key, "http://www.w3.org/2000/xmlns/", pair.Value);
}
private void RrecursiveParse(XPathNavigator navigator)
{
var namespaces = navigator.GetNamespacesInScope(XmlNamespaceScope.Local);
foreach (var map in namespaces)
{
if (String.IsNullOrEmpty(map.Key))
DefaultNamespaces.Add(map.Value);
else if (!Namespaces.ContainsKey(map.Key))
Namespaces.Add(map.Key, map.Value);
}
// process child element nodes
if (navigator.HasChildren
&& (ParseChildren || navigator.NodeType == XPathNodeType.Root)
&& navigator.MoveToFirstChild())
{
do
{
RrecursiveParse(navigator);
}
while (navigator.MoveToNext(XPathNodeType.Element));
// move back to the original parent node
navigator.MoveToParent();
}
}
protected static bool TryParseRssResource(XPathNavigator resource, out XPathNavigator navigator, out Version version)
{
// Local members
//------------------------------------------------------------
bool resourceConformsToFormat = false;
XmlNamespaceManager manager = null;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Initialize namespace resolver
//------------------------------------------------------------
manager = new XmlNamespaceManager(resource.NameTable);
manager.AddNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
manager.AddNamespace("rss09", "http://my.netscape.com/rdf/simple/0.9/");
manager.AddNamespace("rss10", "http://purl.org/rss/1.0/");
//------------------------------------------------------------
// Determine if resource conforms to syndication format
//------------------------------------------------------------
version = null;
if ((navigator = resource.SelectSingleNode("rss", manager)) != null)
{
//------------------------------------------------------------
// Extract version and namespaces of resource
//------------------------------------------------------------
version = SyndicationResourceMetadata.GetVersionFromAttribute(navigator, "version");
Dictionary<string, string> namespaces = (Dictionary<string, string>)navigator.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
resourceConformsToFormat = true;
if (version == null)
{
version = new Version(2, 0);
}
}
else if ((navigator = resource.SelectSingleNode("rdf:RDF", manager)) != null)
{
//------------------------------------------------------------
// Extract version and namespaces of resource
//------------------------------------------------------------
version = SyndicationResourceMetadata.GetVersionFromAttribute(navigator, "version");
Dictionary<string, string> namespaces = (Dictionary<string, string>)navigator.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
if (namespaces.ContainsValue("http://purl.org/rss/1.0/"))
{
resourceConformsToFormat = true;
version = new Version(1, 0);
}
else if (namespaces.ContainsValue("http://my.netscape.com/rdf/simple/0.9/"))
{
resourceConformsToFormat = true;
version = new Version(0, 9);
}
}
return resourceConformsToFormat;
}
protected static bool TryParseRsdResource(XPathNavigator resource, out XPathNavigator navigator, out Version version)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool resourceConformsToFormat = false;
XmlNamespaceManager manager = null;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Initialize namespace resolver
//------------------------------------------------------------
manager = new XmlNamespaceManager(resource.NameTable);
manager.AddNamespace("rsd", "http://archipelago.phrasewise.com/rsd");
//------------------------------------------------------------
// Determine if resource conforms to syndication format
//------------------------------------------------------------
version = null;
if ((navigator = resource.SelectSingleNode("rsd", manager)) != null || (navigator = resource.SelectSingleNode("rsd:rsd", manager)) != null)
{
//------------------------------------------------------------
// Extract version and namespaces of resource
//------------------------------------------------------------
version = SyndicationResourceMetadata.GetVersionFromAttribute(navigator, "version");
Dictionary<string, string> namespaces = (Dictionary<string, string>)navigator.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
if (namespaces.ContainsValue("http://archipelago.phrasewise.com/rsd"))
{
resourceConformsToFormat = true;
if (version == null)
{
version = new Version(1, 0);
}
}
else if (String.Compare(navigator.Name, "rsd", StringComparison.OrdinalIgnoreCase) == 0 && version != null)
{
// Most web log software actually fails to provide the default XML namespace per RSD spec, so this is a hack/compromise
resourceConformsToFormat = true;
}
}
return resourceConformsToFormat;
}
protected static bool TryParseOpenSearchDescriptionResource(XPathNavigator resource, out XPathNavigator navigator, out Version version)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool resourceConformsToFormat = false;
XmlNamespaceManager manager = null;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Initialize namespace resolver
//------------------------------------------------------------
manager = new XmlNamespaceManager(resource.NameTable);
manager.AddNamespace("search", "http://a9.com/-/spec/opensearch/1.1/");
//------------------------------------------------------------
// Determine if resource conforms to syndication format
//------------------------------------------------------------
version = null;
if ((navigator = resource.SelectSingleNode("OpenSearchDescription", manager)) != null || (navigator = resource.SelectSingleNode("search:OpenSearchDescription", manager)) != null)
{
//------------------------------------------------------------
// Extract version and namespaces of resource
//------------------------------------------------------------
version = SyndicationResourceMetadata.GetVersionFromAttribute(navigator, "version");
Dictionary<string, string> namespaces = (Dictionary<string, string>)navigator.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
if (namespaces.ContainsValue("http://a9.com/-/spec/opensearch/1.1/"))
{
resourceConformsToFormat = true;
if (version == null)
{
version = new Version(1, 1);
}
}
}
return resourceConformsToFormat;
}
protected static bool TryParseMicroSummaryGeneratorResource(XPathNavigator resource, out XPathNavigator navigator, out Version version)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool resourceConformsToFormat = false;
XmlNamespaceManager manager = null;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Initialize namespace resolver
//------------------------------------------------------------
manager = new XmlNamespaceManager(resource.NameTable);
manager.AddNamespace("micro", "http://www.mozilla.org/microsummaries/0.1");
//------------------------------------------------------------
// Determine if resource conforms to syndication format
//------------------------------------------------------------
version = null;
if ((navigator = resource.SelectSingleNode("generator", manager)) != null || (navigator = resource.SelectSingleNode("micro:generator", manager)) != null)
{
//------------------------------------------------------------
// Extract version and namespaces of resource
//------------------------------------------------------------
version = SyndicationResourceMetadata.GetVersionFromAttribute(navigator, "version");
Dictionary<string, string> namespaces = (Dictionary<string, string>)navigator.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
if (namespaces.ContainsValue("http://www.mozilla.org/microsummaries/0.1"))
{
resourceConformsToFormat = true;
if (version == null)
{
version = new Version(0, 1);
}
}
}
return resourceConformsToFormat;
}
protected static bool TryParseAtomResource(XPathNavigator resource, out XPathNavigator navigator, out Version version)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool resourceConformsToFormat = false;
XmlNamespaceManager manager = null;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Initialize namespace resolver
//------------------------------------------------------------
manager = new XmlNamespaceManager(resource.NameTable);
manager.AddNamespace("atom", "http://www.w3.org/2005/Atom");
manager.AddNamespace("atom03", "http://purl.org/atom/ns#");
//------------------------------------------------------------
// Determine if resource conforms to syndication format
//------------------------------------------------------------
version = null;
if ((navigator = resource.SelectSingleNode("feed", manager)) != null || (navigator = resource.SelectSingleNode("atom:feed", manager)) != null || (navigator = resource.SelectSingleNode("atom03:feed", manager)) != null)
{
//------------------------------------------------------------
// Extract version and namespaces of feed
//------------------------------------------------------------
version = SyndicationResourceMetadata.GetVersionFromAttribute(navigator, "version");
Dictionary<string, string> namespaces = (Dictionary<string, string>)navigator.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
if (namespaces.ContainsValue("http://www.w3.org/2005/Atom"))
{
resourceConformsToFormat = true;
if (version == null)
{
version = new Version(1, 0);
}
}
else if (namespaces.ContainsValue("http://purl.org/atom/ns#"))
{
resourceConformsToFormat = true;
if (version == null)
{
version = new Version(0, 3);
}
}
}
else if ((navigator = resource.SelectSingleNode("entry", manager)) != null || (navigator = resource.SelectSingleNode("atom:entry", manager)) != null || (navigator = resource.SelectSingleNode("atom03:entry", manager)) != null)
{
//------------------------------------------------------------
// Extract version and namespaces of entry
//------------------------------------------------------------
version = SyndicationResourceMetadata.GetVersionFromAttribute(navigator, "version");
Dictionary<string, string> namespaces = (Dictionary<string, string>)navigator.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
if (namespaces.ContainsValue("http://www.w3.org/2005/Atom"))
{
resourceConformsToFormat = true;
if (version == null)
{
version = new Version(1, 0);
}
}
else if (namespaces.ContainsValue("http://purl.org/atom/ns#"))
{
resourceConformsToFormat = true;
if (version == null)
{
version = new Version(0, 3);
}
}
}
return resourceConformsToFormat;
}
/// <summary>
/// Extracts the content format, version, and XML namespaces for a syndication resource from the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="resource">The <see cref="XPathNavigator"/> to extract the syndication resource meta-data from.</param>
/// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception>
private void Load(XPathNavigator resource)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
XPathNavigator navigator = null;
Version version = null;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Get XML namespaces declared on syndication resource
//------------------------------------------------------------
Dictionary<string, string> namespaces = (Dictionary<string, string>)resource.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml);
foreach (string prefix in namespaces.Keys)
{
resourceNamespaces.Add(prefix, namespaces[prefix]);
}
//------------------------------------------------------------
// Get syndication resource format version using
// version XML attribute
//------------------------------------------------------------
resourceVersion = SyndicationResourceMetadata.GetVersionFromAttribute(resource, "version");
//------------------------------------------------------------
// Determine content format based on root element qualified name
// and expected XML namespace(s)
//------------------------------------------------------------
if (SyndicationResourceMetadata.TryParseApmlResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.Apml;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseAtomResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.Atom;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseAtomPublishingCategoriesResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.AtomCategoryDocument;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseAtomPublishingServiceResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.AtomServiceDocument;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseBlogMLResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.BlogML;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseMicroSummaryGeneratorResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.MicroSummaryGenerator;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseNewsMLResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.NewsML;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseOpenSearchDescriptionResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.OpenSearchDescription;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseOpmlResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.Opml;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseRsdResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.Rsd;
resourceRootNode = navigator;
resourceVersion = version;
}
else if (SyndicationResourceMetadata.TryParseRssResource(resource, out navigator, out version))
{
resourceFormat = SyndicationContentFormat.Rss;
resourceRootNode = navigator;
resourceVersion = version;
}
else
{
resourceFormat = SyndicationContentFormat.None;
resourceRootNode = null;
resourceVersion = null;
}
}
/// <summary>
/// Reads an XPathNavigator object and returns an XmlNamespaceManager containing all namespaces found within it. The default namespace is x.
/// </summary>
/// <param name="xpn">The XPathNavigator to be assessed for namespaces</param>
/// <returns></returns>
public static XmlNamespaceManager GetXmlNamespaceManager(XPathNavigator xpn)
{
xpn.MoveToFollowing(XPathNodeType.Element);
XmlNamespaceManager xmlnsm = new XmlNamespaceManager(xpn.NameTable);
xmlnsm.AddNamespace("x", xpn.NamespaceURI);
foreach (KeyValuePair<string, string> xns in xpn.GetNamespacesInScope(XmlNamespaceScope.All))
xmlnsm.AddNamespace(xns.Key, xns.Value);
return xmlnsm;
}
protected object namespace_uri_for_prefix(object prefix, XPathNavigator element)
{
// fn:namespace-uri-for-prefix($prefix as xs:string?, $element as element()) as xs:anyURI?
IDictionary<string, string> namespaces = element.GetNamespacesInScope(XmlNamespaceScope.All);
string p = ExtensionObjectConvert.ToString(prefix) ?? "";
string ns;
if (!namespaces.TryGetValue(p, out ns)) {
return ExtensionObjectConvert.EmptyIterator;
}
return ns;
}
protected object in_scope_prefixes(XPathNavigator element)
{
// fn:in-scope-prefixes($element as element()) as xs:string*
return ExtensionObjectConvert.ToInputOrEmpty(element.GetNamespacesInScope(XmlNamespaceScope.All).Keys);
}
IDictionary <string, string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope)
{
return(_nav.GetNamespacesInScope(scope));
}
