mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
940 lines
25 KiB
C#
940 lines
25 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
namespace System.ServiceModel.Dispatcher
|
|
{
|
|
using System.Runtime;
|
|
using System.Xml;
|
|
using System.Xml.XPath;
|
|
|
|
#if NO
|
|
//
|
|
// A message is just one more source of Xml data. To filter a message, we create a navigator over it that
|
|
// surfaces its contained Xml to the filter engine.
|
|
// In M5.1, we navigate messages by first writing them into a message document. This turns the message into an
|
|
// Xml DOM. we then get a navigator from the DOM.
|
|
// In M5.2, we'll navigate messages without requiring this step.
|
|
//
|
|
internal class MessageNavigator : GenericSeekableNavigator
|
|
{
|
|
StringBuilder builder;
|
|
int headerCollectionVersion;
|
|
bool loaded;
|
|
bool navigatesBody;
|
|
|
|
internal MessageNavigator(MessageNavigator nav)
|
|
: base(nav)
|
|
{
|
|
this.headerCollectionVersion = nav.headerCollectionVersion;
|
|
this.loaded = nav.loaded;
|
|
this.navigatesBody = nav.navigatesBody;
|
|
}
|
|
|
|
internal MessageNavigator(Message message, bool navigateBody)
|
|
: base()
|
|
{
|
|
this.navigatesBody = navigateBody;
|
|
this.Load(message, this.navigatesBody);
|
|
}
|
|
|
|
internal bool IsLoaded
|
|
{
|
|
get
|
|
{
|
|
return this.loaded;
|
|
}
|
|
}
|
|
|
|
internal bool NavigatesBody
|
|
{
|
|
get
|
|
{
|
|
return this.navigatesBody;
|
|
}
|
|
}
|
|
|
|
internal override void Clear()
|
|
{
|
|
base.Clear();
|
|
this.loaded = false;
|
|
this.navigatesBody = false;
|
|
}
|
|
|
|
public override XPathNavigator Clone()
|
|
{
|
|
return new MessageNavigator(this);
|
|
}
|
|
|
|
internal MessageNavigator Ensure(Message message, bool navigateBody)
|
|
{
|
|
// Rebuild the navigator if:
|
|
// If this navigator does not navigate on bodies and now we need to (or vice versa)
|
|
// Or the header collection changed under us
|
|
if (this.navigatesBody != navigateBody || message.Headers.CollectionVersion != this.headerCollectionVersion)
|
|
{
|
|
this.Load(message, navigateBody);
|
|
}
|
|
else
|
|
{
|
|
this.MoveToRoot();
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
// To load a message into a message document, we write the message into a buffer and then let XPathDocument
|
|
// load that buffer
|
|
internal void Load(Message message, bool navigatesBody)
|
|
{
|
|
if (null == this.builder)
|
|
{
|
|
this.builder = new StringBuilder(1024);
|
|
}
|
|
|
|
StringWriter stringWriter = new StringWriter(this.builder);
|
|
XmlWriter writer = new XmlTextWriter(stringWriter);
|
|
|
|
message.WriteMessage(writer, navigatesBody);
|
|
writer.Close();
|
|
|
|
StringReader reader = new StringReader(this.builder.ToString());
|
|
XPathDocument messageDoc = new XPathDocument(reader);
|
|
reader.Close();
|
|
this.builder.Length = 0;
|
|
|
|
this.Init(messageDoc.CreateNavigator());
|
|
this.loaded = true;
|
|
this.navigatesBody = navigatesBody;
|
|
this.headerCollectionVersion = message.Headers.CollectionVersion;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// To prevent XPaths from running forever etc, users can specify limits on:
|
|
// the # of nodes a filter or filter table should inspect
|
|
//
|
|
// This file contains navigators that impose these limits
|
|
|
|
internal interface INodeCounter
|
|
{
|
|
int CounterMarker { get; set; }
|
|
int MaxCounter { set; }
|
|
int ElapsedCount(int marker);
|
|
void Increase();
|
|
void IncreaseBy(int count);
|
|
}
|
|
|
|
internal class DummyNodeCounter : INodeCounter
|
|
{
|
|
internal static DummyNodeCounter Dummy = new DummyNodeCounter();
|
|
public int CounterMarker
|
|
{
|
|
get { return 0; }
|
|
set { }
|
|
}
|
|
|
|
public int MaxCounter
|
|
{
|
|
set { }
|
|
}
|
|
|
|
public int ElapsedCount(int marker) { return 0; }
|
|
|
|
public void Increase() { }
|
|
public void IncreaseBy(int count) { }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Seekable navigators that wrap other navigators and doesn't exceed node counting limits
|
|
/// </summary>
|
|
internal class SafeSeekableNavigator : SeekableXPathNavigator, INodeCounter
|
|
{
|
|
SeekableXPathNavigator navigator;
|
|
SafeSeekableNavigator counter;
|
|
int nodeCount;
|
|
int nodeCountMax;
|
|
|
|
internal SafeSeekableNavigator(SafeSeekableNavigator nav)
|
|
{
|
|
this.navigator = (SeekableXPathNavigator)nav.navigator.Clone();
|
|
this.counter = nav.counter;
|
|
}
|
|
|
|
internal SafeSeekableNavigator(SeekableXPathNavigator navigator, int nodeCountMax)
|
|
{
|
|
this.navigator = navigator;
|
|
this.counter = this;
|
|
this.nodeCount = nodeCountMax;
|
|
this.nodeCountMax = nodeCountMax;
|
|
}
|
|
|
|
public override string BaseURI
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.BaseURI;
|
|
}
|
|
}
|
|
|
|
public int CounterMarker
|
|
{
|
|
get
|
|
{
|
|
return this.counter.nodeCount;
|
|
}
|
|
set
|
|
{
|
|
this.counter.nodeCount = value;
|
|
}
|
|
}
|
|
|
|
public int MaxCounter
|
|
{
|
|
set
|
|
{
|
|
this.counter.nodeCountMax = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setting the current position moves this navigator to the location specified by the given position
|
|
/// </summary>
|
|
public override long CurrentPosition
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.CurrentPosition;
|
|
}
|
|
set
|
|
{
|
|
this.navigator.CurrentPosition = value;
|
|
}
|
|
}
|
|
|
|
public override bool HasAttributes
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.HasAttributes;
|
|
}
|
|
}
|
|
|
|
public override bool HasChildren
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.HasChildren;
|
|
}
|
|
}
|
|
|
|
public override bool IsEmptyElement
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.IsEmptyElement;
|
|
}
|
|
}
|
|
|
|
public override string LocalName
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.LocalName;
|
|
}
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.Name;
|
|
}
|
|
}
|
|
|
|
public override string NamespaceURI
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.NamespaceURI;
|
|
}
|
|
}
|
|
|
|
public override XmlNameTable NameTable
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.NameTable;
|
|
}
|
|
}
|
|
|
|
public override XPathNodeType NodeType
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.NodeType;
|
|
}
|
|
}
|
|
|
|
public override string Prefix
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.Prefix;
|
|
}
|
|
}
|
|
|
|
public override string Value
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.Value;
|
|
}
|
|
}
|
|
|
|
public override string XmlLang
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.XmlLang;
|
|
}
|
|
}
|
|
|
|
public override XPathNavigator Clone()
|
|
{
|
|
return new SafeSeekableNavigator(this);
|
|
}
|
|
|
|
#if NO
|
|
internal SafeNavigator CreateSafeXPathNavigator()
|
|
{
|
|
return new SafeNavigator(this, this.navigator);
|
|
}
|
|
#endif
|
|
public override XmlNodeOrder ComparePosition(XPathNavigator navigator)
|
|
{
|
|
if (navigator == null)
|
|
{
|
|
return XmlNodeOrder.Unknown;
|
|
}
|
|
|
|
SafeSeekableNavigator nav = navigator as SafeSeekableNavigator;
|
|
if (nav != null)
|
|
{
|
|
return this.navigator.ComparePosition(nav.navigator);
|
|
}
|
|
return XmlNodeOrder.Unknown;
|
|
}
|
|
|
|
public override XmlNodeOrder ComparePosition(long x, long y)
|
|
{
|
|
return this.navigator.ComparePosition(x, y);
|
|
}
|
|
|
|
public int ElapsedCount(int marker)
|
|
{
|
|
return marker - this.counter.nodeCount;
|
|
}
|
|
|
|
public override string GetLocalName(long nodePosition)
|
|
{
|
|
return this.navigator.GetLocalName(nodePosition);
|
|
}
|
|
|
|
public override string GetName(long nodePosition)
|
|
{
|
|
return this.navigator.GetName(nodePosition);
|
|
}
|
|
|
|
public override string GetNamespace(long nodePosition)
|
|
{
|
|
return this.navigator.GetNamespace(nodePosition);
|
|
}
|
|
|
|
public override XPathNodeType GetNodeType(long nodePosition)
|
|
{
|
|
return this.navigator.GetNodeType(nodePosition);
|
|
}
|
|
|
|
public override string GetValue(long nodePosition)
|
|
{
|
|
return this.navigator.GetValue(nodePosition);
|
|
}
|
|
|
|
public override string GetNamespace(string name)
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.GetNamespace(name);
|
|
}
|
|
|
|
public override string GetAttribute(string localName, string namespaceURI)
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.GetAttribute(localName, namespaceURI);
|
|
}
|
|
|
|
public void Increase()
|
|
{
|
|
this.IncrementNodeCount();
|
|
}
|
|
|
|
public void IncreaseBy(int count)
|
|
{
|
|
this.counter.nodeCount -= (count - 1);
|
|
Increase();
|
|
}
|
|
|
|
internal void IncrementNodeCount()
|
|
{
|
|
if (this.counter.nodeCount > 0)
|
|
{
|
|
this.counter.nodeCount--;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XPathNavigatorException(SR.GetString(SR.FilterNodeQuotaExceeded, this.counter.nodeCountMax)));
|
|
}
|
|
}
|
|
#if NO
|
|
internal virtual void Init(SeekableXPathNavigator navigator, int nodeCountMax)
|
|
{
|
|
this.navigator = navigator;
|
|
this.nodeCount = nodeCountMax;
|
|
this.counter = this;
|
|
}
|
|
#endif
|
|
public override bool IsDescendant(XPathNavigator navigator)
|
|
{
|
|
if (navigator == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
SafeSeekableNavigator nav = navigator as SafeSeekableNavigator;
|
|
if (nav != null)
|
|
{
|
|
return this.navigator.IsDescendant(nav.navigator);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override bool IsSamePosition(XPathNavigator other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
SafeSeekableNavigator nav = other as SafeSeekableNavigator;
|
|
if (nav != null)
|
|
{
|
|
return this.navigator.IsSamePosition(nav.navigator);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override void MoveToRoot()
|
|
{
|
|
this.IncrementNodeCount();
|
|
this.navigator.MoveToRoot();
|
|
}
|
|
|
|
public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToNextNamespace(namespaceScope);
|
|
}
|
|
|
|
public override bool MoveToNextAttribute()
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToNextAttribute();
|
|
}
|
|
|
|
public override bool MoveToPrevious()
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToPrevious();
|
|
}
|
|
|
|
public override bool MoveToFirstAttribute()
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToFirstAttribute();
|
|
}
|
|
|
|
public override bool MoveToNamespace(string name)
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToNamespace(name);
|
|
}
|
|
|
|
public override bool MoveToParent()
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToParent();
|
|
}
|
|
|
|
public override bool MoveTo(XPathNavigator other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
this.IncrementNodeCount();
|
|
SafeSeekableNavigator nav = other as SafeSeekableNavigator;
|
|
if (nav != null)
|
|
{
|
|
return this.navigator.MoveTo(nav.navigator);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override bool MoveToId(string id)
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToId(id);
|
|
}
|
|
|
|
public override bool MoveToFirstChild()
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToFirstChild();
|
|
}
|
|
|
|
public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToFirstNamespace(namespaceScope);
|
|
}
|
|
|
|
public override bool MoveToAttribute(string localName, string namespaceURI)
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToAttribute(localName, namespaceURI);
|
|
}
|
|
|
|
public override bool MoveToNext()
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToNext();
|
|
}
|
|
|
|
public override bool MoveToFirst()
|
|
{
|
|
this.IncrementNodeCount();
|
|
return this.navigator.MoveToFirst();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The filter engine works with seekable navigators. This class takes a generic XPathNavigator implementation
|
|
/// and transforms it into a seekable navigator. Seekable navigators associate a 'position' to every node in a DOM.
|
|
///
|
|
/// This class maintains a (position, navigator) map. Cloning navigators is unavoidable - XPathNavigator offers
|
|
/// no other way to snapshot its current position. However, caching allows memory allocations to be avoided - but
|
|
/// only once the navigator is warmed up.
|
|
/// </summary>
|
|
internal class GenericSeekableNavigator : SeekableXPathNavigator
|
|
{
|
|
QueryBuffer<XPathNavigator> nodes;
|
|
long currentPosition;
|
|
XPathNavigator navigator;
|
|
|
|
GenericSeekableNavigator dom;
|
|
#if NO
|
|
internal GenericSeekableNavigator()
|
|
{
|
|
this.nodes = new QueryBuffer<XPathNavigator>(4);
|
|
this.currentPosition = -1;
|
|
}
|
|
#endif
|
|
internal GenericSeekableNavigator(XPathNavigator navigator)
|
|
{
|
|
this.navigator = navigator;
|
|
this.nodes = new QueryBuffer<XPathNavigator>(4);
|
|
this.currentPosition = -1;
|
|
this.dom = this;
|
|
}
|
|
|
|
internal GenericSeekableNavigator(GenericSeekableNavigator navigator)
|
|
{
|
|
this.navigator = navigator.navigator.Clone();
|
|
this.nodes = default(QueryBuffer<XPathNavigator>);
|
|
this.currentPosition = navigator.currentPosition;
|
|
this.dom = navigator.dom;
|
|
}
|
|
|
|
public override string BaseURI
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.BaseURI;
|
|
}
|
|
}
|
|
|
|
public override bool HasAttributes
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.HasAttributes;
|
|
}
|
|
}
|
|
|
|
public override bool HasChildren
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.HasChildren;
|
|
}
|
|
}
|
|
|
|
#if NO
|
|
internal XPathNavigator InternalNavigator
|
|
{
|
|
get
|
|
{
|
|
return this.navigator;
|
|
}
|
|
}
|
|
#endif
|
|
public override bool IsEmptyElement
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.IsEmptyElement;
|
|
}
|
|
}
|
|
|
|
public override string LocalName
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.LocalName;
|
|
}
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.Name;
|
|
}
|
|
}
|
|
|
|
public override string NamespaceURI
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.NamespaceURI;
|
|
}
|
|
}
|
|
|
|
public override XmlNameTable NameTable
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.NameTable;
|
|
}
|
|
}
|
|
|
|
public override XPathNodeType NodeType
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.NodeType;
|
|
}
|
|
}
|
|
|
|
public override string Prefix
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.Prefix;
|
|
}
|
|
}
|
|
|
|
public override string Value
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.Value;
|
|
}
|
|
}
|
|
|
|
public override string XmlLang
|
|
{
|
|
get
|
|
{
|
|
return this.navigator.XmlLang;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Setting the current position moves this navigator to the location specified by the given position
|
|
/// </summary>
|
|
public override long CurrentPosition
|
|
{
|
|
get
|
|
{
|
|
if (-1 == this.currentPosition)
|
|
{
|
|
this.SnapshotNavigator();
|
|
}
|
|
return this.currentPosition;
|
|
}
|
|
set
|
|
{
|
|
this.navigator.MoveTo(this[value]);
|
|
this.currentPosition = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the XPathNavigator that has the given position
|
|
/// </summary>
|
|
internal XPathNavigator this[long nodePosition]
|
|
{
|
|
get
|
|
{
|
|
int pos = (int)nodePosition;
|
|
Fx.Assert(this.dom.nodes.IsValidIndex(pos) && null != this.dom.nodes[pos], "");
|
|
return this.dom.nodes[pos];
|
|
}
|
|
}
|
|
|
|
#if NO
|
|
internal virtual void Clear()
|
|
{
|
|
this.navigator = null;
|
|
this.currentPosition = -1;
|
|
}
|
|
#endif
|
|
public override XPathNavigator Clone()
|
|
{
|
|
return new GenericSeekableNavigator(this);
|
|
}
|
|
|
|
public override XmlNodeOrder ComparePosition(XPathNavigator navigator)
|
|
{
|
|
if (navigator == null)
|
|
{
|
|
return XmlNodeOrder.Unknown;
|
|
}
|
|
|
|
GenericSeekableNavigator nav = navigator as GenericSeekableNavigator;
|
|
if (nav != null)
|
|
{
|
|
return this.navigator.ComparePosition(nav.navigator);
|
|
}
|
|
return XmlNodeOrder.Unknown;
|
|
}
|
|
|
|
public override XmlNodeOrder ComparePosition(long x, long y)
|
|
{
|
|
XPathNavigator nodeX = this[x];
|
|
XPathNavigator nodeY = this[y];
|
|
|
|
return nodeX.ComparePosition(nodeY);
|
|
}
|
|
|
|
public override string GetLocalName(long nodePosition)
|
|
{
|
|
return this[nodePosition].LocalName;
|
|
}
|
|
|
|
public override string GetName(long nodePosition)
|
|
{
|
|
return this[nodePosition].Name;
|
|
}
|
|
|
|
public override string GetNamespace(long nodePosition)
|
|
{
|
|
return this[nodePosition].NamespaceURI;
|
|
}
|
|
|
|
public override XPathNodeType GetNodeType(long nodePosition)
|
|
{
|
|
return this[nodePosition].NodeType;
|
|
}
|
|
|
|
public override string GetValue(long nodePosition)
|
|
{
|
|
return this[nodePosition].Value;
|
|
}
|
|
|
|
public override string GetNamespace(string name)
|
|
{
|
|
return this.navigator.GetNamespace(name);
|
|
}
|
|
|
|
public override string GetAttribute(string localName, string namespaceURI)
|
|
{
|
|
return this.navigator.GetAttribute(localName, namespaceURI);
|
|
}
|
|
|
|
#if NO
|
|
internal void Init(XPathNavigator navigator)
|
|
{
|
|
Fx.Assert(null != navigator, "");
|
|
this.navigator = navigator;
|
|
this.currentPosition = -1;
|
|
}
|
|
#endif
|
|
public override bool IsDescendant(XPathNavigator navigator)
|
|
{
|
|
if (navigator == null)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
GenericSeekableNavigator nav = navigator as GenericSeekableNavigator;
|
|
if (null != nav)
|
|
{
|
|
return this.navigator.IsDescendant(nav.navigator);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override bool IsSamePosition(XPathNavigator other)
|
|
{
|
|
GenericSeekableNavigator nav = other as GenericSeekableNavigator;
|
|
if (null != nav)
|
|
{
|
|
return this.navigator.IsSamePosition(nav.navigator);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public override void MoveToRoot()
|
|
{
|
|
this.currentPosition = -1;
|
|
this.navigator.MoveToRoot();
|
|
}
|
|
|
|
public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToNextNamespace(namespaceScope);
|
|
}
|
|
|
|
public override bool MoveToNextAttribute()
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToNextAttribute();
|
|
}
|
|
|
|
public override bool MoveToPrevious()
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToPrevious();
|
|
}
|
|
|
|
public override bool MoveToFirstAttribute()
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToFirstAttribute();
|
|
}
|
|
|
|
public override bool MoveToNamespace(string name)
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToNamespace(name);
|
|
}
|
|
|
|
public override bool MoveToParent()
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToParent();
|
|
}
|
|
|
|
public override bool MoveTo(XPathNavigator other)
|
|
{
|
|
GenericSeekableNavigator nav = other as GenericSeekableNavigator;
|
|
if (null != nav)
|
|
{
|
|
if (this.navigator.MoveTo(nav.navigator))
|
|
{
|
|
this.currentPosition = nav.currentPosition;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool MoveToId(string id)
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToId(id);
|
|
}
|
|
|
|
public override bool MoveToFirstChild()
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToFirstChild();
|
|
}
|
|
|
|
public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToFirstNamespace(namespaceScope);
|
|
}
|
|
|
|
public override bool MoveToAttribute(string localName, string namespaceURI)
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToAttribute(localName, namespaceURI);
|
|
}
|
|
|
|
public override bool MoveToNext()
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToNext();
|
|
}
|
|
|
|
public override bool MoveToFirst()
|
|
{
|
|
this.currentPosition = -1;
|
|
return this.navigator.MoveToFirst();
|
|
}
|
|
|
|
internal void SnapshotNavigator()
|
|
{
|
|
this.currentPosition = this.dom.nodes.Count;
|
|
this.dom.nodes.Add(this.navigator.Clone());
|
|
/*
|
|
if (this.currentPosition < this.nodes.Count)
|
|
{
|
|
// Use a cached navigator
|
|
XPathNavigator clonedNavigator = this.nodes[(int)this.currentPosition];
|
|
Fx.Assert(null != clonedNavigator, "");
|
|
clonedNavigator.MoveTo(this);
|
|
}
|
|
else
|
|
{
|
|
this.nodes.Add(this.navigator.Clone());
|
|
}
|
|
*/
|
|
}
|
|
|
|
#region IQueryBufferPool Members
|
|
#if NO
|
|
/// <summary>
|
|
/// Reset the pool by deleting it entirely and starting it over
|
|
/// </summary>
|
|
public void Reset()
|
|
{
|
|
this.nodes.count = 0;
|
|
this.nodes.TrimToCount();
|
|
}
|
|
|
|
public void Trim()
|
|
{
|
|
this.nodes.TrimToCount();
|
|
}
|
|
#endif
|
|
#endregion
|
|
}
|
|
}
|