public static string GetXPath (XPathNavigator n)
{
switch (n.NodeType) {
case XPathNodeType.Root: return "/";
case XPathNodeType.Attribute: {
string ret = "@" + n.Name;
n.MoveToParent ();
string s = GetXPath (n);
return s + (s == "/" ? "" : "/") + ret;
}
case XPathNodeType.Element: {
string ret = n.Name;
int i = 1;
while (n.MoveToPrevious ()) {
if (n.NodeType == XPathNodeType.Element && n.Name == ret)
i++;
}
ret += "[" + i + "]";
if (n.MoveToParent ()) {
string s = GetXPath (n);
return s + (s == "/" ? "" : "/") + ret;
}
}
break;
}
throw new Exception ("node type not supported for editing");
}
public CreateCone(System.Xml.XPath.XPathNavigator navigator, GEMSSingle parent)
: base(navigator, parent)
{
alineAxis = (Axis)Enum.Parse(typeof(Axis), navigator.GetAttribute("axis", string.Empty));
//Bottom radius of cylinder
navigator.MoveToChild("BottomRadius", string.Empty);
bottomRadius = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent( );
//Top radius of cylinder
navigator.MoveToChild("TopRadius", string.Empty);
topRadius = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent( );
//Height of cylinder
navigator.MoveToChild("Height", string.Empty);
height = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent( );
//Center of cylinder
navigator.MoveToChild("Center", string.Empty);
center = new Vector3WithUnit( );
center.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty));
center.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty));
center.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty));
navigator.MoveToParent( );
}
public CreateCuboid(System.Xml.XPath.XPathNavigator navigator, GEMSSingle parent)
: base(navigator, parent)
{
//Width of box
navigator.MoveToChild("Width", string.Empty);
width = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent();
//Depth of box
navigator.MoveToChild("Depth", string.Empty);
depth = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent();
//Height of box
navigator.MoveToChild("Height", string.Empty);
height = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent();
//Reference point of box
navigator.MoveToChild("RefPoint", string.Empty);
refPoint = new Vector3WithUnit();
refPoint.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty));
refPoint.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty));
refPoint.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty));
navigator.MoveToParent();
}
public void ReadXml(XPathNavigator node)
{
if (node.MoveToFirstAttribute()) {
do {
if (String.IsNullOrEmpty(node.NamespaceURI)) {
switch (node.LocalName) {
case "address":
this.Address = node.Value;
break;
case "display-name":
this.DisplayName = node.Value;
break;
default:
break;
}
}
} while (node.MoveToNextAttribute());
node.MoveToParent();
}
}
public ParameterNode(XPathNavigator aNode)
{
valueNode = String.Empty;
typeNode = String.Empty;
ruleValueNode = String.Empty;
name = String.Empty;
if (aNode.MoveToFirstAttribute())
{
do
{
string nodeName = aNode.Name;
switch (nodeName)
{
case PARAMETER_ATTRS.NAME:
name = aNode.Value;
break;
case PARAMETER_ATTRS.VALUE:
valueNode = aNode.Value;
break;
case PARAMETER_ATTRS.TYPE:
typeNode = aNode.Value;
break;
case PARAMETER_ATTRS.RULE_VALUE:
ruleValueNode = aNode.Value;
break;
}
} while (aNode.MoveToNextAttribute());
aNode.MoveToParent();
}
}
public CreateSphere(System.Xml.XPath.XPathNavigator navigator, GEMSSingle parent)
: base(navigator, parent)
{
//Radius of sphere
navigator.MoveToChild("Radius", string.Empty);
radius = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent();
//Center of sphere
navigator.MoveToChild("Center", string.Empty);
center = new Vector3WithUnit();
center.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty));
center.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty));
center.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty));
navigator.MoveToParent();
}
static void FullName(XPathNavigator navigator, StringBuilder s)
{
if (navigator.NodeType == XPathNodeType.Root)
return;
string name = navigator.Name;
string value = null;
XPathNodeType nodeType = navigator.NodeType;
if (nodeType == XPathNodeType.Attribute)
value = navigator.Value;
int same = 0;
int position = 0;
XPathNavigator sibling = navigator.Clone();
sibling.MoveToFirst();
do
{
if (sibling.NodeType == nodeType && sibling.Name == name)
{
if (sibling.IsSamePosition(navigator))
position = same;
else
++same;
}
} while (sibling.MoveToNext());
if (navigator.MoveToParent())
FullName(navigator, s);
switch (nodeType)
{
case XPathNodeType.Element:
s.Append('/');
s.Append(name);
if (same != 0)
{
s.Append('[');
s.Append((position + 1).ToString(CultureInfo.InvariantCulture));
s.Append(']');
}
break;
case XPathNodeType.Attribute:
s.Append("[@");
s.Append(name);
if (same != 0)
s.AppendFormat(" = '{0}'", value);
s.Append("]");
break;
case XPathNodeType.Comment:
case XPathNodeType.Namespace:
case XPathNodeType.ProcessingInstruction:
case XPathNodeType.Root:
case XPathNodeType.Text:
case XPathNodeType.Whitespace:
default:
throw new NotSupportedException();
}
}
public CreateRound(System.Xml.XPath.XPathNavigator navigator, GEMSSingle parent)
: base(navigator, parent)
{
alineAxis = (Axis)Enum.Parse(typeof(Axis), navigator.GetAttribute("axis", string.Empty));
//Radius of circle
navigator.MoveToChild("Radius", string.Empty);
radius = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent();
//Center of circle
navigator.MoveToChild("Center", string.Empty);
center = new Vector3WithUnit();
center.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty));
center.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty));
center.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty));
navigator.MoveToParent();
}
public void ReadXml(XPathNavigator node, XmlResolver resolver)
{
if (node.NodeType == XPathNodeType.Element) {
if (node.MoveToFirstAttribute()) {
do {
switch (node.LocalName) {
case "media-type":
this.MediaType = node.Value;
break;
case "boundary":
this.Boundary = node.Value;
break;
}
} while (node.MoveToNextAttribute());
node.MoveToParent();
}
if (node.MoveToChild(XPathNodeType.Element)) {
XPathHttpMultipartItem currentItem = null;
do {
if (node.NamespaceURI == XPathHttpClient.Namespace) {
switch (node.LocalName) {
case "header":
if (currentItem == null) {
currentItem = new XPathHttpMultipartItem();
}
currentItem.Headers.Add(node.GetAttribute("name", ""), node.GetAttribute("value", ""));
break;
case "body":
if (currentItem == null) {
currentItem = new XPathHttpMultipartItem();
}
currentItem.Body = new XPathHttpBody();
currentItem.Body.ReadXml(node, resolver);
this.Items.Add(currentItem);
currentItem = null;
break;
}
}
} while (node.MoveToNext(XPathNodeType.Element));
node.MoveToParent();
}
}
}
private string GetChildNodesValue(XPathNavigator nav, string nodeName)
{
string value = string.Empty;
if (nav.MoveToChild(nodeName, ""))
{
value = nav.Value;
nav.MoveToParent();
}
return value;
}
public CreatePoint(System.Xml.XPath.XPathNavigator navigator, GEMSSingle parent)
: base(navigator, parent)
{
//Position of Point
navigator.MoveToChild("Position", string.Empty);
position = new Vector3WithUnit();
position.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty));
position.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty));
position.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty));
navigator.MoveToParent();
}
public static void SetOrCreateXmlAttribute(XPathNavigator node, string localName, string namespaceURI, string value)
{
if (node.MoveToAttribute(localName, namespaceURI))
{
node.SetValue(value);
node.MoveToParent();
}
else
{
node.CreateAttribute("", localName, namespaceURI, value);
}
}
public static Dictionary<string, string> GetAttributes(XPathNavigator navigator)
{
if (!navigator.MoveToFirstAttribute())
throw new DeserializationException("Node has no attributes: " + navigator.Name);
Dictionary<string, string> attributes = new Dictionary<string, string>();
do
{
attributes.Add(navigator.Name, navigator.Value);
} while (navigator.MoveToNextAttribute());
navigator.MoveToParent();
return attributes;
}
public static IEnumerable<XPathNavigator> EnumerateChildren(XPathNavigator navigator)
{
if (navigator.MoveToFirstChild())
{
do
{
yield return navigator;
} while (navigator.MoveToNext());
navigator.MoveToParent();
}
}
public void ReadXml(XPathNavigator node) {
if (node.MoveToFirstAttribute()) {
do {
if (String.IsNullOrEmpty(node.NamespaceURI)) {
switch (node.LocalName) {
case "method":
switch (node.Value) {
case "xml":
this.Method = XmlSerializationOptions.Methods.Xml;
break;
case "html":
this.Method = XmlSerializationOptions.Methods.Html;
break;
case "xhtml":
this.Method = XmlSerializationOptions.Methods.XHtml;
break;
case "text":
this.Method = XmlSerializationOptions.Methods.Text;
break;
}
break;
default:
break;
}
}
} while (node.MoveToNextAttribute());
node.MoveToParent();
}
if (node.MoveToFirstChild()) {
do {
if (node.NodeType == XPathNodeType.Element || node.NodeType == XPathNodeType.Text) {
this.Content = node.Clone();
break;
}
} while (node.MoveToNext());
node.MoveToParent();
}
}
public CreateLine(System.Xml.XPath.XPathNavigator navigator, GEMSSingle parent)
: base(navigator, parent)
{
navigator.MoveToChild("Positions", string.Empty);
navigator.MoveToFirstChild();
//Start Point of line
startPoint = new Vector3WithUnit();
startPoint.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty));
startPoint.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty));
startPoint.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty));
//End Point of line
navigator.MoveToNext();
endPoint = new Vector3WithUnit();
endPoint.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty));
endPoint.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty));
endPoint.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty));
navigator.MoveToParent();
navigator.MoveToParent();
}
public CreateRectangle(System.Xml.XPath.XPathNavigator navigator, GEMSSingle parent)
: base(navigator, parent)
{
alineAxis = (Axis)Enum.Parse(typeof(Axis), navigator.GetAttribute("axis", string.Empty));
//Width of rectangle
navigator.MoveToChild("Width", string.Empty);
width = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent();
//Height of rectangle
navigator.MoveToChild("Height", string.Empty);
height = new Length(navigator.GetAttribute("value", string.Empty), navigator.GetAttribute("unit", string.Empty));
navigator.MoveToParent();
//Reference point of rectangle
navigator.MoveToChild("RefPoint", string.Empty);
refPoint = new Vector3WithUnit();
refPoint.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty));
refPoint.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty));
refPoint.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty));
navigator.MoveToParent();
}
//creates a dictionary of values found in XML
private static Dictionary<string, string> ResourceDataToDictionary(XPathNavigator xPathNavigator)
{
Dictionary<string, string> dict = new Dictionary<string, string>();
if (xPathNavigator.MoveToFirstChild()) //children
{
dict.Add(xPathNavigator.Name, xPathNavigator.Value);
while (xPathNavigator.MoveToNext())
{
dict.Add(xPathNavigator.Name, xPathNavigator.Value);
}
}
xPathNavigator.MoveToParent();
return dict;
}
private void AddAttributeList(XPathNavigator nav, ArrayList attrs)
{
if (nav.HasAttributes)
{
nav.MoveToFirstAttribute();
do
{
if (!attrs.Contains(nav.Name))
{
attrs.Add(nav.Name);
}
}
while (nav.MoveToNextAttribute());
nav.MoveToParent();
}
}
/// <summary>
/// Walks the XPathNavigator tree recursively
/// </summary>
/// <param name="myXPathNavigator"></param>
public static void DisplayTree(XPathNavigator myXPathNavigator)
{
if (myXPathNavigator.HasChildren)
{
myXPathNavigator.MoveToFirstChild();
Format(myXPathNavigator);
DisplayTree(myXPathNavigator);
myXPathNavigator.MoveToParent();
}
while (myXPathNavigator.MoveToNext())
{
Format(myXPathNavigator);
DisplayTree(myXPathNavigator);
}
}
public IList<string> GrabBackDropUrls(XPathNavigator nav)
{
List<string> urls = new List<string>();
XPathNodeIterator nIter = nav.SelectChildren("backdrop", "");
if (nav.MoveToFollowing("backdrop", ""))
{
XPathNavigator localNav = nav.CreateNavigator();
nav.MoveToParent();
for (int i = 0; i < nIter.Count; i++)
{
if (localNav.GetAttribute("size", "").ToUpperInvariant().Equals("original".ToUpperInvariant()))
urls.Add(localNav.Value);
localNav.MoveToNext();
}
}
return urls;
}
/// <summary>
/// WebDav Property.
/// </summary>
/// <param name="property"></param>
public DavProperty(XPathNavigator property)
{
if (property == null)
throw new ArgumentNullException("property", InternalFunctions.GetResourceString("ArgumentNullException", "Property"));
else if (property.NodeType != XPathNodeType.Element)
throw new ArgumentException(InternalFunctions.GetResourceString("XPathNavigatorElementArgumentException", "Property"), "property");
base.Name = property.LocalName;
base.Namespace = property.NamespaceURI;
if (property.HasAttributes)
{
//TODO: Support element attributes
//string _here = "";
//Add the attributes first
// foreach (XmlAttribute _xmlAttribute in property.Attributes)
// Attributes.Add(new DavPropertyAttribute(_xmlAttribute));
}
if (property.MoveToFirstChild())
{
if (property.NodeType == XPathNodeType.Element)
{
NestedProperties.Add(new DavProperty(property.Clone()));
while (property.MoveToNext())
{
if (property.NodeType == XPathNodeType.Element)
NestedProperties.Add(new DavProperty(property.Clone()));
}
}
else if (property.NodeType == XPathNodeType.Text)
{
base.Value = property.Value;
property.MoveToParent();
}
}
}
/// <summary>
/// Updates all of the <c>Torrent</c> object's properties.
/// </summary>
/// <param name="node">Torrent XML node</param>
public void update(XPathNavigator node)
{
node.MoveToFirstChild();
hash = node.Value;
node.MoveToNext();
status = Convert.ToInt64(node.Value);
node.MoveToNext();
name = node.Value;
node.MoveToNext();
size = Convert.ToInt64(node.Value);
node.MoveToNext();
percent_progress = Convert.ToInt64(node.Value);
// skip a tonne of properties
for (int i = 0; i < 17; i++) node.MoveToNext();
status_message = node.Value;
calculateStatus();
last_modified = DateTime.Now;
// be kind, rewind
node.MoveToParent();
}
override internal XPathNavigator advancefordescendant() {
XPathNavigator result = null;
ArrayList elementList = new ArrayList();
int i = 0;
_eLast = m_qyInput.advance();
while (_eLast != null){
for(i = 0; i < elementList.Count; i++ ) {
if ( ((XPathNavigator)elementList[i]).IsDescendant(_eLast)) {
break;
}
}
if ( i == _pathstack.Count )
break;
_eLast = m_qyInput.advance();
}
if (_eLast == null )
return null;
result = _eLast.Clone();
while (true) {
if (_fMatchSelf)
if (matches( _eLast))
result.MoveTo(_eLast);
if (!_eLast.MoveToParent())
{
elementList.Add(result);
return result;
}
else{
if (matches(_eLast)){
result.MoveTo(_eLast);
}
}
}
}
public void RecursiveWalkThroughXpath(XPathNavigator navigator)
{
switch (navigator.NodeType)
{
case XPathNodeType.Root:
//TODO: do this better ie parse xml or html decelration
if (IncludeDocType)
{
textWriter.Write("!!!");
textWriter.Write(Environment.NewLine);
}
break;
case XPathNodeType.Element:
ProcessElement(navigator);
break;
case XPathNodeType.Text:
ProcessText(navigator);
break;
}
if (navigator.MoveToFirstChild())
{
do
{
RecursiveWalkThroughXpath(navigator);
} while (navigator.MoveToNext());
navigator.MoveToParent();
CheckUnIndent(navigator);
}
else
{
CheckUnIndent(navigator);
}
}
internal override XPathNavigator advance()
{
if (_eLast == null)
{
XPathNavigator temp = null;
_eLast = m_qyInput.advance();
if (_eLast == null)
{
return(null);
}
while (_eLast != null)
{
_eLast = _eLast.Clone();
temp = _eLast;
_eLast = m_qyInput.advance();
if (!temp.IsDescendant(_eLast))
{
break;
}
}
_eLast = temp;
}
while (true)
{
if (_first)
{
_first = false;
if (_eLast.NodeType == XPathNodeType.Attribute || _eLast.NodeType == XPathNodeType.Namespace)
{
_eLast.MoveToParent();
if (_fMatchName)
{
_qy = _eLast.SelectDescendants(m_Name, m_URN, false);
}
else
{
_qy = _eLast.SelectDescendants(m_Type, false);
}
}
else
{
while (true)
{
if (!_eLast.MoveToNext())
{
if (!_eLast.MoveToParent())
{
_first = true;
return(null);
}
}
else
{
break;
}
}
if (_fMatchName)
{
_qy = _eLast.SelectDescendants(m_Name, m_URN, true);
}
else
{
_qy = _eLast.SelectDescendants(m_Type, true);
}
}
}
if (_qy.MoveNext())
{
_position++;
m_eNext = _qy.Current;
return(m_eNext);
}
else
{
_first = true;
}
}
}
public virtual XmlNodeOrder ComparePosition(XPathNavigator nav)
{
if (IsSamePosition(nav))
{
return(XmlNodeOrder.Same);
}
if (IsDescendant(nav))
{
return(XmlNodeOrder.Before);
}
else if (nav.IsDescendant(this))
{
return(XmlNodeOrder.After);
}
XPathNavigator copy = this.Clone();
XPathNavigator other = nav.Clone();
/* now, it gets expensive - we find the
* closest common ancestor. But these two
* might be from totally different places.
*
* Someone should re-implement this somewhere,
* so that it is faster for XmlDocument.
*/
int common = 0;
int otherDepth = 0;
int copyDepth = 0;
copy.MoveToRoot();
other.MoveToRoot();
if (!copy.IsSamePosition(other))
{
return(XmlNodeOrder.Unknown);
}
/* what do you think ? I'm made of GC space ? */
copy.MoveTo(this);
other.MoveTo(nav);
while (other.MoveToParent())
{
otherDepth++;
}
while (copy.MoveToParent())
{
copyDepth++;
}
common = (otherDepth > copyDepth) ? copyDepth : otherDepth;
other.MoveTo(nav);
copy.MoveTo(this);
// traverse both till you get to depth == common
for (; otherDepth > common; otherDepth--)
{
other.MoveToParent();
}
for (; copyDepth > common; copyDepth--)
{
copy.MoveToParent();
}
other.MoveTo(nav);
copy.MoveTo(this);
XPathNavigator copy1 = copy.Clone();
XPathNavigator other1 = other.Clone();
while (copy.IsSamePosition(other))
{
copy1.MoveTo(copy);
other1.MoveTo(other);
copy.MoveToParent();
other.MoveToParent();
}
copy.MoveTo(copy1);
other.MoveTo(other1);
// Now copy & other are siblings and can be compared
while (copy.MoveToNext())
{
if (copy.IsSamePosition(other))
{
return(XmlNodeOrder.Before);
}
}
return(XmlNodeOrder.After);
}
protected XPathNavigator MatchNode(XPathNavigator current, IQuery query)
{
XPathNavigator context;
if (current != null)
{
context = query.MatchNode(current);
if (context != null)
{
if (_opnd.ReturnType() == XPathResultType.Number)
{
if (_opnd.getName() == Querytype.Constant)
{
XPathNavigator result = current.Clone();
int i = 0;
if (query.getName() == Querytype.Child)
{
result.MoveToParent();
result.MoveToFirstChild();
while (true)
{
if (((ChildrenQuery)query).matches(result))
{
i++;
if (current.IsSamePosition(result))
{
if (XmlConvert.ToXPathDouble(_opnd.getValue(current, null)) == i)
{
return(context);
}
else
{
return(null);
}
}
}
if (!result.MoveToNext())
{
return(null);
}
}
}
if (query.getName() == Querytype.Attribute)
{
result.MoveToParent();
result.MoveToFirstAttribute();
while (true)
{
if (((AttributeQuery)query).matches(result))
{
i++;
}
if (current.IsSamePosition(result))
{
if (XmlConvert.ToXPathDouble(_opnd.getValue(current, null)) == i)
{
return(context);
}
else
{
return(null);
}
}
if (!result.MoveToNextAttribute())
{
return(null);
}
}
}
}
else
{
setContext(context.Clone());
XPathNavigator result = advance();
while (result != null)
{
if (result.IsSamePosition(current))
{
return(context);
}
result = advance();
}
}
}
if (_opnd.ReturnType() == XPathResultType.NodeSet)
{
_opnd.setContext(current);
if (_opnd.advance() != null)
{
return(context);
}
else
{
return(null);
}
}
if (_opnd.ReturnType() == XPathResultType.Boolean)
{
if (noPosition)
{
if ((bool)_opnd.getValue(current, null))
{
return(context);
}
return(null);
}
setContext(context.Clone());
XPathNavigator result = advance();
while (result != null)
{
if (result.IsSamePosition(current))
{
return(context);
}
result = advance();
}
return(null);
}
if (_opnd.ReturnType() == XPathResultType.String)
{
if (_opnd.getValue(context, null).ToString().Length > 0)
{
return(context);
}
else
{
return(null);
}
}
}
else
{
return(null);
}
}
return(null);
}
public static void WriteNode(this XmlWriter writer, XPathNavigator navigator, bool defattr)
{
if (navigator == null)
{
throw new ArgumentNullException("navigator");
}
int iLevel = 0;
navigator = navigator.Clone();
while (true)
{
bool mayHaveChildren = false;
XPathNodeType nodeType = navigator.NodeType;
switch (nodeType)
{
case XPathNodeType.Element:
writer.WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
// Copy attributes
if (navigator.MoveToFirstAttribute())
{
do
{
writer.WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI);
// copy string value to writer
writer.WriteString(navigator.Value);
writer.WriteEndAttribute();
} while (navigator.MoveToNextAttribute());
navigator.MoveToParent();
}
// Copy namespaces
if (navigator.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
writer.WriteLocalNamespaces(navigator);
navigator.MoveToParent();
}
mayHaveChildren = true;
break;
case XPathNodeType.Attribute:
// do nothing on root level attribute
break;
case XPathNodeType.Text:
writer.WriteString(navigator.Value);
break;
case XPathNodeType.SignificantWhitespace:
case XPathNodeType.Whitespace:
writer.WriteWhitespace(navigator.Value);
break;
case XPathNodeType.Root:
mayHaveChildren = true;
break;
case XPathNodeType.Comment:
writer.WriteComment(navigator.Value);
break;
case XPathNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(navigator.LocalName, navigator.Value);
break;
case XPathNodeType.Namespace:
// do nothing on root level namespace
break;
default:
Debug.Assert(false);
break;
}
if (mayHaveChildren)
{
// If children exist, move down to next level
if (navigator.MoveToFirstChild())
{
iLevel++;
continue;
}
else
{
// EndElement
if (navigator.NodeType == XPathNodeType.Element)
{
if (navigator.IsEmptyElement)
{
writer.WriteEndElement();
}
else
{
writer.WriteFullEndElement();
}
}
}
}
// No children
while (true)
{
if (iLevel == 0)
{
// The entire subtree has been copied
return;
}
if (navigator.MoveToNext())
{
// Found a sibling, so break to outer loop
break;
}
// No siblings, so move up to previous level
iLevel--;
navigator.MoveToParent();
// EndElement
if (navigator.NodeType == XPathNodeType.Element)
{
writer.WriteFullEndElement();
}
}
}
}
public virtual XmlNodeOrder ComparePosition(XPathNavigator nav)
{
if (IsSamePosition(nav))
{
return(XmlNodeOrder.Same);
}
// quick check for direct descendant
if (IsDescendant(nav))
{
return(XmlNodeOrder.Before);
}
// quick check for direct ancestor
if (nav.IsDescendant(this))
{
return(XmlNodeOrder.After);
}
XPathNavigator nav1 = Clone();
XPathNavigator nav2 = nav.Clone();
// check if document instance is the same.
nav1.MoveToRoot();
nav2.MoveToRoot();
if (!nav1.IsSamePosition(nav2))
{
return(XmlNodeOrder.Unknown);
}
nav1.MoveTo(this);
nav2.MoveTo(nav);
int depth1 = 0;
while (nav1.MoveToParent())
{
depth1++;
}
nav1.MoveTo(this);
int depth2 = 0;
while (nav2.MoveToParent())
{
depth2++;
}
nav2.MoveTo(nav);
// find common parent depth
int common = depth1;
for (; common > depth2; common--)
{
nav1.MoveToParent();
}
for (int i = depth2; i > common; i--)
{
nav2.MoveToParent();
}
while (!nav1.IsSamePosition(nav2))
{
nav1.MoveToParent();
nav2.MoveToParent();
common--;
}
// For each this and target, move to the node that is
// ancestor of the node and child of the common parent.
nav1.MoveTo(this);
for (int i = depth1; i > common + 1; i--)
{
nav1.MoveToParent();
}
nav2.MoveTo(nav);
for (int i = depth2; i > common + 1; i--)
{
nav2.MoveToParent();
}
// Those children of common parent are comparable.
// namespace nodes precede to attributes, and they
// precede to other nodes.
if (nav1.NodeType == XPathNodeType.Namespace)
{
if (nav2.NodeType != XPathNodeType.Namespace)
{
return(XmlNodeOrder.Before);
}
while (nav1.MoveToNextNamespace())
{
if (nav1.IsSamePosition(nav2))
{
return(XmlNodeOrder.Before);
}
}
return(XmlNodeOrder.After);
}
if (nav2.NodeType == XPathNodeType.Namespace)
{
return(XmlNodeOrder.After);
}
if (nav1.NodeType == XPathNodeType.Attribute)
{
if (nav2.NodeType != XPathNodeType.Attribute)
{
return(XmlNodeOrder.Before);
}
while (nav1.MoveToNextAttribute())
{
if (nav1.IsSamePosition(nav2))
{
return(XmlNodeOrder.Before);
}
}
return(XmlNodeOrder.After);
}
while (nav1.MoveToNext())
{
if (nav1.IsSamePosition(nav2))
{
return(XmlNodeOrder.Before);
}
}
return(XmlNodeOrder.After);
}
public MSXslScript (XPathNavigator nav, Evidence evidence)
{
this.evidence = evidence;
code = nav.Value;
if (nav.MoveToFirstAttribute ()) {
do {
switch (nav.LocalName) {
case "language":
switch (nav.Value.ToLower (CultureInfo.InvariantCulture)) {
case "jscript":
case "javascript":
language = ScriptingLanguage.JScript; break;
case "vb":
case "visualbasic":
language = ScriptingLanguage.VisualBasic;
break;
case "c#":
case "csharp":
language = ScriptingLanguage.CSharp;
break;
default:
throw new XsltException ("Invalid scripting language!", null);
}
break;
case "implements-prefix":
implementsPrefix = nav.Value;
break;
}
} while (nav.MoveToNextAttribute ());
nav.MoveToParent ();
}
if (implementsPrefix == null)
throw new XsltException ("need implements-prefix attr", null);
}
/// <summary>
/// Move to the next reader state. Return false if that is ReaderState.Closed.
/// </summary>
public override bool Read()
{
_attrCount = -1;
switch (_state)
{
case State.Error:
case State.Closed:
case State.EOF:
return false;
case State.Initial:
// Starting state depends on the navigator's item type
_nav = _navToRead;
_state = State.Content;
if (XPathNodeType.Root == _nav.NodeType)
{
if (!_nav.MoveToFirstChild())
{
SetEOF();
return false;
}
_readEntireDocument = true;
}
else if (XPathNodeType.Attribute == _nav.NodeType)
{
_state = State.Attribute;
}
_nodeType = ToXmlNodeType(_nav.NodeType);
break;
case State.Content:
if (_nav.MoveToFirstChild())
{
_nodeType = ToXmlNodeType(_nav.NodeType);
_depth++;
_state = State.Content;
}
else if (_nodeType == XmlNodeType.Element
&& !_nav.IsEmptyElement)
{
_nodeType = XmlNodeType.EndElement;
_state = State.EndElement;
}
else
goto case State.EndElement;
break;
case State.EndElement:
if (0 == _depth && !_readEntireDocument)
{
SetEOF();
return false;
}
else if (_nav.MoveToNext())
{
_nodeType = ToXmlNodeType(_nav.NodeType);
_state = State.Content;
}
else if (_depth > 0 && _nav.MoveToParent())
{
Debug.Assert(_nav.NodeType == XPathNodeType.Element, _nav.NodeType.ToString() + " == XPathNodeType.Element");
_nodeType = XmlNodeType.EndElement;
_state = State.EndElement;
_depth--;
}
else
{
SetEOF();
return false;
}
break;
case State.Attribute:
case State.AttrVal:
if (!_nav.MoveToParent())
{
SetEOF();
return false;
}
_nodeType = ToXmlNodeType(_nav.NodeType);
_depth--;
if (_state == State.AttrVal)
_depth--;
goto case State.Content;
case State.InReadBinary:
_state = _savedState;
_readBinaryHelper.Finish();
return Read();
}
return true;
}
public override string GetAttribute(string name)
{
string str;
string str2;
XPathNavigator nav = this.nav;
switch (nav.NodeType)
{
case XPathNodeType.Element:
break;
case XPathNodeType.Attribute:
nav = nav.Clone();
if (nav.MoveToParent())
{
break;
}
return(null);
default:
return(null);
}
ValidateNames.SplitQName(name, out str, out str2);
if (str.Length == 0)
{
if (str2 == "xmlns")
{
return(nav.GetNamespace(string.Empty));
}
if (nav == this.nav)
{
nav = nav.Clone();
}
if (nav.MoveToAttribute(str2, string.Empty))
{
return(nav.Value);
}
}
else
{
if (str == "xmlns")
{
return(nav.GetNamespace(str2));
}
if (nav == this.nav)
{
nav = nav.Clone();
}
if (nav.MoveToFirstAttribute())
{
do
{
if ((nav.LocalName == str2) && (nav.Prefix == str))
{
return(nav.Value);
}
}while (nav.MoveToNextAttribute());
}
}
return(null);
}
public override bool MoveToNextAttribute()
{
switch (this.state)
{
case State.Content:
return(this.MoveToFirstAttribute());
case State.Attribute:
if (XPathNodeType.Attribute != this.nav.NodeType)
{
XPathNavigator other = this.nav.Clone();
if (other.MoveToParent())
{
if (!other.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
return(false);
}
if (other.IsSamePosition(this.nav))
{
other.MoveToParent();
if (!other.MoveToFirstAttribute())
{
return(false);
}
this.nav.MoveTo(other);
return(true);
}
XPathNavigator navigator2 = other.Clone();
while (other.MoveToNextNamespace(XPathNamespaceScope.Local))
{
if (other.IsSamePosition(this.nav))
{
this.nav.MoveTo(navigator2);
return(true);
}
navigator2.MoveTo(other);
}
}
return(false);
}
return(this.nav.MoveToNextAttribute());
case State.AttrVal:
this.depth--;
this.state = State.Attribute;
if (this.MoveToNextAttribute())
{
break;
}
this.depth++;
this.state = State.AttrVal;
return(false);
case State.InReadBinary:
this.state = this.savedState;
if (this.MoveToNextAttribute())
{
this.readBinaryHelper.Finish();
return(true);
}
this.state = State.InReadBinary;
return(false);
default:
return(false);
}
this.nodeType = XmlNodeType.Attribute;
return(true);
}
public override bool MoveToNextAttribute()
{
switch (this.state)
{
case State.Content:
return(MoveToFirstAttribute());
case State.Attribute: {
if (XPathNodeType.Attribute == this.nav.NodeType)
{
return(this.nav.MoveToNextAttribute());
}
// otherwise it is on a namespace... namespace are in reverse order
Debug.Assert(XPathNodeType.Namespace == this.nav.NodeType);
XPathNavigator nav = this.nav.Clone();
if (!nav.MoveToParent())
{
return(false); // shouldn't happen
}
if (!nav.MoveToFirstNamespace(XPathNamespaceScope.Local))
{
return(false); // shouldn't happen
}
if (nav.IsSamePosition(this.nav))
{
// this was the last one... start walking attributes
nav.MoveToParent();
if (!nav.MoveToFirstAttribute())
{
return(false);
}
// otherwise we are there
this.nav.MoveTo(nav);
return(true);
}
else
{
XPathNavigator prev = nav.Clone();
for (;;)
{
if (!nav.MoveToNextNamespace(XPathNamespaceScope.Local))
{
Debug.Fail("Couldn't find Namespace Node! Should not happen!");
return(false);
}
if (nav.IsSamePosition(this.nav))
{
this.nav.MoveTo(prev);
return(true);
}
prev.MoveTo(nav);
}
// found previous namespace position
}
}
case State.AttrVal:
depth--;
this.state = State.Attribute;
if (!MoveToNextAttribute())
{
depth++;
this.state = State.AttrVal;
return(false);
}
this.nodeType = XmlNodeType.Attribute;
return(true);
case State.InReadBinary:
state = savedState;
if (!MoveToNextAttribute())
{
state = State.InReadBinary;
return(false);
}
readBinaryHelper.Finish();
return(true);
default:
return(false);
}
}
public override string GetAttribute(string name)
{
// reader allows calling GetAttribute, even when positioned inside attributes
XPathNavigator nav = this.nav;
switch (nav.NodeType)
{
case XPathNodeType.Element:
break;
case XPathNodeType.Attribute:
nav = nav.Clone();
if (!nav.MoveToParent())
{
return(null);
}
break;
default:
return(null);
}
string prefix, localname;
ValidateNames.SplitQName(name, out prefix, out localname);
if (0 == prefix.Length)
{
if (localname == "xmlns")
{
return(nav.GetNamespace(string.Empty));
}
if ((object)nav == (object)this.nav)
{
nav = nav.Clone();
}
if (nav.MoveToAttribute(localname, string.Empty))
{
return(nav.Value);
}
}
else
{
if (prefix == "xmlns")
{
return(nav.GetNamespace(localname));
}
if ((object)nav == (object)this.nav)
{
nav = nav.Clone();
}
if (nav.MoveToFirstAttribute())
{
do
{
if (nav.LocalName == localname && nav.Prefix == prefix)
{
return(nav.Value);
}
} while (nav.MoveToNextAttribute());
}
}
return(null);
}
private bool moveToCount(XPathNavigator nav, Processor processor, XPathNavigator contextNode) {
do {
if (this.fromKey != Compiler.InvalidQueryKey && processor.Matches(nav, this.fromKey)) {
return false;
}
if (MatchCountKey(processor, contextNode, nav)) {
return true;
}
}while (nav.MoveToParent());
return false;
}
/// <summary>
/// Initialize the ParentIterator.
/// </summary>
public void Create(XPathNavigator context, XmlNavigatorFilter filter)
{
// Save context node as current node
_navCurrent = XmlQueryRuntime.SyncToNavigator(_navCurrent, context);
// Attempt to find a matching parent node
_haveCurrent = (_navCurrent.MoveToParent()) && (!filter.IsFiltered(_navCurrent));
}
bool IReflectorPersistance.Load(System.Xml.XPath.XPathNavigator r)
{
if (r.NodeType == XPathNodeType.Element)
{
osalot.AssemblyTracker tracker = new osalot.AssemblyTracker();
string location = null;
switch (r.Name)
{
case "Plugins":
bool everokay = false;
bool okay;
for (okay = r.MoveToFirstAttribute(); okay; okay = r.MoveToNextAttribute())
{
everokay = true;
switch (r.Name)
{
case "Location":
location = r.Value;
break;
}
}
if (everokay)
{
r.MoveToParent();
}
everokay = false;
for (okay = r.MoveToFirstChild(); okay; okay = r.MoveToNext())
{
everokay = true;
switch (r.Name)
{
case "System Mask":
tracker.allow_on_system.Add(r.Value);
break;
}
}
if (everokay)
{
r.MoveToParent();
}
if (tracker.allow_on_system.Count == 0)
{
core_common.LoadAssembly(location, tracker);
}
else
{
foreach (String s in tracker.allow_on_system)
{
Match m = Regex.Match(SystemInformation.ComputerName, s);
if (m.Success)
{
core_common.LoadAssembly(location, tracker);
break;
}
}
}
return(true);
}
return(false);
}
return(false);
}
public virtual bool IsDescendant (XPathNavigator nav)
{
if (nav != null)
{
nav = nav.Clone ();
while (nav.MoveToParent ())
{
if (IsSamePosition (nav))
return true;
}
}
return false;
}
/// <summary>
/// Position "nav" to the matching node which follows it in document order but is not a descendant node.
/// Return false if this is no such matching node.
/// </summary>
internal static bool MoveFirst(XmlNavigatorFilter filter, XPathNavigator nav) {
// Attributes and namespace nodes include descendants of their owner element in the set of following nodes
if (nav.NodeType == XPathNodeType.Attribute || nav.NodeType == XPathNodeType.Namespace) {
if (!nav.MoveToParent()) {
// Floating attribute or namespace node that has no following nodes
return false;
}
if (!filter.MoveToFollowing(nav, null)) {
// No matching following nodes
return false;
}
}
else {
// XPath spec doesn't include descendants of the input node in the following axis
if (!nav.MoveToNonDescendant())
// No following nodes
return false;
// If the sibling does not match the node-test, find the next following node that does
if (filter.IsFiltered(nav)) {
if (!filter.MoveToFollowing(nav, null)) {
// No matching following nodes
return false;
}
}
}
// Success
return true;
}
static IEnumerable EnumerateChildren (XPathNavigator n, string name, string ns)
{
if (!n.MoveToFirstChild ())
yield break;
n.MoveToParent ();
XPathNavigator nav = n.Clone ();
nav.MoveToFirstChild ();
XPathNavigator nav2 = nav.Clone ();
do {
if ((name == String.Empty || nav.LocalName == name) && (ns == String.Empty || nav.NamespaceURI == ns)) {
nav2.MoveTo (nav);
yield return nav2;
}
} while (nav.MoveToNext ());
}
public override string GetAttribute( string name ) {
// reader allows calling GetAttribute, even when positioned inside attributes
XPathNavigator nav = this.nav;
switch (nav.NodeType) {
case XPathNodeType.Element:
break;
case XPathNodeType.Attribute:
nav = nav.Clone();
if (!nav.MoveToParent())
return null;
break;
default:
return null;
}
string prefix, localname;
ValidateNames.SplitQName( name, out prefix, out localname );
if ( 0 == prefix.Length ) {
if( localname == "xmlns" )
return nav.GetNamespace( string.Empty );
if ( (object)nav == (object)this.nav )
nav = nav.Clone();
if ( nav.MoveToAttribute( localname, string.Empty ) )
return nav.Value;
}
else {
if( prefix == "xmlns" )
return nav.GetNamespace( localname );
if ((object)nav == (object)this.nav)
nav = nav.Clone();
if (nav.MoveToFirstAttribute()) {
do {
if (nav.LocalName == localname && nav.Prefix == prefix)
return nav.Value;
} while (nav.MoveToNextAttribute());
}
}
return null;
}
public virtual bool Matches(XPathExpression expr)
{
Expression e = ((CompiledExpression)expr).ExpressionNode;
if (e is ExprRoot)
{
return(NodeType == XPathNodeType.Root);
}
NodeTest nt = e as NodeTest;
if (nt != null)
{
switch (nt.Axis.Axis)
{
case Axes.Child:
case Axes.Attribute:
break;
default:
throw new XPathException("Only child and attribute pattern are allowed for a pattern.");
}
return(nt.Match(((CompiledExpression)expr).NamespaceManager, this));
}
if (e is ExprFilter)
{
do
{
e = ((ExprFilter)e).LeftHandSide;
} while (e is ExprFilter);
if (e is NodeTest && !((NodeTest)e).Match(((CompiledExpression)expr).NamespaceManager, this))
{
return(false);
}
}
XPathResultType resultType = e.ReturnType;
switch (resultType)
{
case XPathResultType.Any:
case XPathResultType.NodeSet:
break;
default:
return(false);
}
switch (e.EvaluatedNodeType)
{
case XPathNodeType.Attribute:
case XPathNodeType.Namespace:
if (NodeType != e.EvaluatedNodeType)
{
return(false);
}
break;
}
XPathNodeIterator nodes;
nodes = this.Select(expr);
while (nodes.MoveNext())
{
if (IsSamePosition(nodes.Current))
{
return(true);
}
}
// ancestors might select this node.
XPathNavigator navigator = Clone();
while (navigator.MoveToParent())
{
nodes = navigator.Select(expr);
while (nodes.MoveNext())
{
if (IsSamePosition(nodes.Current))
{
return(true);
}
}
}
return(false);
}
static IEnumerable EnumerateChildren (XPathNavigator n, XPathNodeType type)
{
if (!n.MoveToFirstChild ())
yield break;
n.MoveToParent ();
XPathNavigator nav = n.Clone ();
nav.MoveToFirstChild ();
XPathNavigator nav2 = null;
do {
if (type == XPathNodeType.All || nav.NodeType == type) {
if (nav2 == null)
nav2 = nav.Clone ();
else
nav2.MoveTo (nav);
yield return nav2;
}
} while (nav.MoveToNext ());
}
public override string GetAttribute( string localName, string namespaceURI ) {
if ( null == localName )
throw new ArgumentNullException("localName");
// reader allows calling GetAttribute, even when positioned inside attributes
XPathNavigator nav = this.nav;
switch (nav.NodeType) {
case XPathNodeType.Element:
break;
case XPathNodeType.Attribute:
nav = nav.Clone();
if (!nav.MoveToParent())
return null;
break;
default:
return null;
}
// are they really looking for a namespace-decl?
if( namespaceURI == XmlReservedNs.NsXmlNs ) {
if (localName == "xmlns")
localName = string.Empty;
return nav.GetNamespace( localName );
}
if ( null == namespaceURI )
namespaceURI = string.Empty;
// We need to clone the navigator and move the clone to the attribute to see whether the attribute exists,
// because XPathNavigator.GetAttribute return string.Empty for both when the the attribute is not there or when
// it has an empty value. XmlReader.GetAttribute must return null if the attribute does not exist.
if ((object)nav == (object)this.nav)
nav = nav.Clone();
if ( nav.MoveToAttribute( localName, namespaceURI ) ) {
return nav.Value;
}
else {
return null;
}
}
// check 'from' condition:
// if 'from' exist it has to be ancestor-or-self for the nav
private bool checkFrom(Processor processor, XPathNavigator nav) {
if(this.fromKey == Compiler.InvalidQueryKey) {
return true;
}
do {
if (processor.Matches(nav, this.fromKey)) {
return true;
}
}while (nav.MoveToParent());
return false;
}
public virtual bool MoveToFollowing(string localName,
string namespaceURI, XPathNavigator end)
{
if (localName == null)
{
throw new ArgumentNullException("localName");
}
if (namespaceURI == null)
{
throw new ArgumentNullException("namespaceURI");
}
localName = NameTable.Get(localName);
if (localName == null)
{
return(false);
}
namespaceURI = NameTable.Get(namespaceURI);
if (namespaceURI == null)
{
return(false);
}
XPathNavigator nav = Clone();
switch (nav.NodeType)
{
case XPathNodeType.Attribute:
case XPathNodeType.Namespace:
nav.MoveToParent();
break;
}
do
{
if (!nav.MoveToFirstChild())
{
do
{
if (!nav.MoveToNext())
{
if (!nav.MoveToParent())
{
return(false);
}
}
else
{
break;
}
} while (true);
}
if (end != null && end.IsSamePosition(nav))
{
return(false);
}
if (object.ReferenceEquals(localName, nav.LocalName) &&
object.ReferenceEquals(namespaceURI, nav.NamespaceURI))
{
MoveTo(nav);
return(true);
}
} while (true);
}
public void Fill (XPathNavigator nav)
{
if (nav.MoveToFirstAttribute ()) {
ProcessAttribute (nav);
while (nav.MoveToNextAttribute ()) {
ProcessAttribute (nav);
}
// move back to original position
nav.MoveToParent ();
}
}
/// <summary>
/// Move to the next reader state. Return false if that is ReaderState.Closed.
/// </summary>
public override bool Read()
{
_attrCount = -1;
switch (_state)
{
case State.Error:
case State.Closed:
case State.EOF:
return(false);
case State.Initial:
// Starting state depends on the navigator's item type
_nav = _navToRead;
_state = State.Content;
if (XPathNodeType.Root == _nav.NodeType)
{
if (!_nav.MoveToFirstChild())
{
SetEOF();
return(false);
}
_readEntireDocument = true;
}
else if (XPathNodeType.Attribute == _nav.NodeType)
{
_state = State.Attribute;
}
_nodeType = ToXmlNodeType(_nav.NodeType);
break;
case State.Content:
if (_nav.MoveToFirstChild())
{
_nodeType = ToXmlNodeType(_nav.NodeType);
_depth++;
_state = State.Content;
}
else if (_nodeType == XmlNodeType.Element &&
!_nav.IsEmptyElement)
{
_nodeType = XmlNodeType.EndElement;
_state = State.EndElement;
}
else
{
goto case State.EndElement;
}
break;
case State.EndElement:
if (0 == _depth && !_readEntireDocument)
{
SetEOF();
return(false);
}
else if (_nav.MoveToNext())
{
_nodeType = ToXmlNodeType(_nav.NodeType);
_state = State.Content;
}
else if (_depth > 0 && _nav.MoveToParent())
{
Debug.Assert(_nav.NodeType == XPathNodeType.Element, _nav.NodeType.ToString() + " == XPathNodeType.Element");
_nodeType = XmlNodeType.EndElement;
_state = State.EndElement;
_depth--;
}
else
{
SetEOF();
return(false);
}
break;
case State.Attribute:
case State.AttrVal:
if (!_nav.MoveToParent())
{
SetEOF();
return(false);
}
_nodeType = ToXmlNodeType(_nav.NodeType);
_depth--;
if (_state == State.AttrVal)
{
_depth--;
}
goto case State.Content;
case State.InReadBinary:
_state = _savedState;
_readBinaryHelper !.Finish();
return(Read());
}
return(true);
}