Clone() public abstract method

public abstract Clone ( ) : XPathNavigator
return XPathNavigator
Example #1
0
        public override bool ParseXML(XPathNavigator node)
        {
            XPathNavigator child = node.Clone();
            base.ParseXML(child);

            child = node.Clone();
            if(child.MoveToChild("name", String.Empty))
                name = child.Value;

            return true;
        }
Example #2
0
		public XPathNavigatorReader (XPathNavigator nav)
		{
			// It seems that this class have only to support linked
			// node as its parameter
			switch (nav.NodeType) {
			case XPathNodeType.Attribute:
			case XPathNodeType.Namespace:
				throw new InvalidOperationException (String.Format ("NodeType {0} is not supported to read as a subtree of an XPathNavigator.", nav.NodeType));
			}
			root = nav.Clone ();
			current = nav.Clone ();
		}
Example #3
0
        public bool ParseXML(XPathNavigator node)
        {
            XPathNavigator child = node.Clone();
            if(child.MoveToChild("id", String.Empty))
                ID = child.ValueAsInt;
            child = node.Clone();
            if(child.MoveToChild("code", String.Empty))
                Code = child.Value;
            child = node.Clone();
            if(child.MoveToChild("name", String.Empty))
                Name = child.Value;

            return true;
        }
        /// <summary>
        ///   Creates a new instance of the <see cref="SchematronValidationEventArgs"/>.
        /// </summary>
        /// <param name="schematron">The <see cref="SchematronDocument"/> that detected the event.</param>
        /// <param name="queryEngine">The <see cref="IQueryLanguage"/> that detected the event.</param>
        /// <param name="pattern">The active <see cref="Pattern"/>.</param>
        /// <param name="rule">The <see cref="Sepia.Schematron.Rule"/> that caused the event to be raised.</param>
        /// <param name="assertion">The <see cref="Sepia.Schematron.Assertion"/> that caused the event to be raised.</param>
        /// <param name="context">An <see cref="object"/> that provides the context for the <paramref name="rule"/> and <paramref name="assertion"/>.</param>
        /// <param name="instance">An <see cref="XPathNavigator"/> to the document node that cause the event to be raised.</param>
        public SchematronValidationEventArgs(SchematronDocument schematron, IQueryLanguage queryEngine, Pattern pattern, Rule rule, Assertion assertion, object context, XPathNavigator instance)
        {
            this.schematron = schematron;
             this.queryEngine = queryEngine;
             this.pattern = pattern;
             this.rule = rule;
             this.assertion = assertion;
             this.instance = instance.Clone();

             if (assertion == null)
             {
            message = "A schematron validation event occured.";
             }
             else
             {
            message = assertion.Message.ToString(instance, context);
             }

             List<string> diagnostics = new List<string>();
             if (assertion != null && !string.IsNullOrEmpty(assertion.Diagnostics))
             {
            foreach (string id in assertion.Diagnostics.Split(' '))
            {
               Diagnostic diagnostic = schematron.Diagnostics[id];
               diagnostics.Add(diagnostic.Message.ToString(instance, context));
            }
             }
             this.diagnostics = diagnostics.ToArray();
        }
Example #5
0
        public override XPathNavigator MatchNode(XPathNavigator context)
        {
            if (context != null)
            {
                if (!abbrAxis)
                {
                    throw XPathException.Create(SR.Xp_InvalidPattern);
                }
                XPathNavigator result = null;
                if (matches(context))
                {
                    if (matchSelf)
                    {
                        if ((result = qyInput.MatchNode(context)) != null)
                        {
                            return result;
                        }
                    }

                    XPathNavigator anc = context.Clone();
                    while (anc.MoveToParent())
                    {
                        if ((result = qyInput.MatchNode(anc)) != null)
                        {
                            return result;
                        }
                    }
                }
            }
            return null;
        }
        // get InnerXml without changing the spacing

        public static string GetInnerXml (XPathNavigator node) {

            // check for null argument, and clone so we don't change input
            if (node == null) throw new ArgumentNullException("node");
	        XPathNavigator current = node.Clone();

		    // create appropriate settings for the output writer
		    XmlWriterSettings settings = new XmlWriterSettings();
		    settings.ConformanceLevel = ConformanceLevel.Fragment;
		    settings.OmitXmlDeclaration = true;

		    // construct a writer for our output
		    StringBuilder builder = new StringBuilder();
		    XmlWriter writer = XmlWriter.Create(builder, settings);

		    // write the output
		    bool writing = current.MoveToFirstChild();
		    while (writing) {
			    current.WriteSubtree(writer);
			    writing = current.MoveToNext();				
		    }

		    // finish up and return the result
		    writer.Close();
		    return(builder.ToString());

        }
		public XPathSimpleIterator(XPathBaseIterator parent) : base (parent)
		{
			this.parent = parent;
			navigator = parent.Current.Clone();
			current = navigator.Clone();
			pos = 0;
		}
        public override XPathNavigator Advance() {
        	while (true) {
                if (currentNode == null) {
                    if (nextInput == null) {
                        nextInput = FetchInput(); // This can happen at the begining and at the end 
                    }
                    if (elementStk.Count == 0) {
                        if (nextInput == null) {
                            return null;
                        }
                        currentNode = nextInput;
                        nextInput = FetchInput();
                    } else {
                        currentNode = elementStk.Pop();
                    }
                }

                while (currentNode.IsDescendant(nextInput)) {
                    elementStk.Push(currentNode);
                    currentNode = nextInput;
                    nextInput = qyInput.Advance();
                    if (nextInput != null) {
                        nextInput = nextInput.Clone();
                    }
                }

				while (currentNode.MoveToNext()) {
				    if (matches(currentNode)) {
				        position++;
    				    return currentNode;
			        }
			    }
		        currentNode = null;
			}
        } // Advance
Example #9
0
 void AddToStack(XPathNavigator current)
 {
     XmlNodeOrder compare;
     for (int i=0; i< ElementList.Count ; i++)
     {
         XPathNavigator nav = ElementList[i] as XPathNavigator;
         compare = nav.ComparePosition(current) ;      
         if (compare == XmlNodeOrder.Same ) return;
         if (compare == XmlNodeOrder.Before)
         {
             ElementList.Insert(i,current.Clone());
             return;
         }
     }
     ElementList.Add(current.Clone());
 }
Example #10
0
        static public XPathNavigatorReader Create(XPathNavigator navToRead)
        {
            XPathNavigator nav = navToRead.Clone();
            IXmlLineInfo xli = nav as IXmlLineInfo;
            IXmlSchemaInfo xsi = nav as IXmlSchemaInfo;
#if NAVREADER_SUPPORTSLINEINFO
            if (null == xsi) {
                if (null == xli) {
                    return new XPathNavigatorReader(nav, xli, xsi);
                }
                else {
                    return new XPathNavigatorReaderWithLI(nav, xli, xsi);
                }
            }
            else {
                if (null == xli) {
                    return new XPathNavigatorReaderWithSI(nav, xli, xsi);
                }
                else {
                    return new XPathNavigatorReaderWithLIAndSI(nav, xli, xsi);
                }
            }
#else
            if (null == xsi)
            {
                return new XPathNavigatorReader(nav, xli, xsi);
            }
            else
            {
                return new XPathNavigatorReaderWithSI(nav, xli, xsi);
            }
#endif
        }
 public override XPathNavigator MatchNode(XPathNavigator context)
 {
     if (context != null)
     {
         if (!this.abbrAxis)
         {
             throw XPathException.Create("Xp_InvalidPattern");
         }
         XPathNavigator navigator = null;
         if (this.matches(context))
         {
             if (this.matchSelf && ((navigator = base.qyInput.MatchNode(context)) != null))
             {
                 return navigator;
             }
             XPathNavigator current = context.Clone();
             while (current.MoveToParent())
             {
                 navigator = base.qyInput.MatchNode(current);
                 if (navigator != null)
                 {
                     return navigator;
                 }
             }
         }
     }
     return null;
 }
Example #12
0
        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();
             }
        }
		private SubtreeeXPathNavigator(XPathNavigator root, XPathNavigator current, 
			bool atRoot, bool enableFragment)
		{
			_root = root.Clone();
			_navigator = current.Clone();
			_atroot = atRoot;
			_fragment = enableFragment;
		} 
Example #14
0
 public XPathSelectionIterator(XPathNavigator nav, XPathExpression expr) {
     this.nav = nav.Clone();
     query = ((CompiledXpathExpr) expr).QueryTree;
     if (query.ReturnType() != XPathResultType.NodeSet) {
         throw new XPathException(Res.Xp_NodeSetExpected);
     }
     query.setContext(nav.Clone());
 }
		/// <summary>
		/// Adds a <see cref="XPathNavigator"/> to the set.
		/// </summary>
		/// <param name="navigator">The navigator to add. It's cloned automatically.</param>
		public void Add(XPathNavigator navigator)
		{
			if (_position != -1) 
				throw new InvalidOperationException(
					SR.XPathNavigatorIterator_CantAddAfterMove);

			_navigators.Add(navigator.Clone());
		}
 protected static XPathNavigator Clone(XPathNavigator input)
 {
     if (input != null)
     {
         return input.Clone();
     }
     return null;
 }
Example #17
0
 public XPathSelectionIterator(XPathNavigator nav, string xpath) {
     this.nav = nav;
     query = new QueryBuilder().Build( xpath, /*allowVar:*/true, /*allowKey:*/true );
     if (query.ReturnType() != XPathResultType.NodeSet) {
         throw new XPathException(Res.Xp_NodeSetExpected);
     }
     query.setContext(nav.Clone());
 }
 public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
 {
     SeekableMessageNavigator navigator = docContext as SeekableMessageNavigator;
     if (navigator != null)
     {
         return navigator.Message.Version.Envelope.Namespace;
     }
     return ExtractFromNavigator(docContext.Clone());
 }
        public static string Translate(XPathNavigator descriptionNode, ReferenceLinkGeneratorDelegate refLinkGenerator)
        {
            // obtaining desc parent node
            var descParentNode = descriptionNode.Clone();
            descParentNode.MoveToParent();

            return ParseXML((XmlNode)descParentNode.UnderlyingObject,
                (XmlNode)descriptionNode.UnderlyingObject, refLinkGenerator);
        }
Example #20
0
 private bool NotVisited(XPathNavigator nav)
 {
     XPathNavigator nav1 = nav.Clone();
     nav1.MoveToParent();
     for(int i=0;i<_ParentStk.Count;i++)
         if (nav1.IsSamePosition((XPathNavigator)_ParentStk[i]))
             return false;
     _ParentStk.Add(nav1);
     return true;
 }
		private void Parse(XPathNavigator eventElement)
		{
			XPathNavigator eventClone = eventElement.Clone();
			eventElement.MoveToFirstAttribute();
			type = CfgXmlHelper.ListenerTypeConvertFrom(eventElement.Value);
			XPathNodeIterator listenersI = eventClone.SelectDescendants(XPathNodeType.Element, false);
			while (listenersI.MoveNext())
			{
				listeners.Add(new ListenerConfiguration(listenersI.Current, type));
			}
		}
 private bool NotVisited(XPathNavigator nav, List<XPathNavigator> parentStk){
     XPathNavigator nav1 = nav.Clone();
     nav1.MoveToParent();
     for (int i = 0; i < parentStk.Count; i++) {
         if (nav1.IsSamePosition(parentStk[i])) {
             return false;
         }
     }
     parentStk.Add(nav1);
     return true;
 }
 private bool Visited(XPathNavigator nav) {
     XPathNavigator parent = nav.Clone();
     parent.MoveToParent();
     for (int i = 0; i < parentStk.Count; i++) {
         if (parent.IsSamePosition(parentStk[i])) {
             return true;
         }
     }
     parentStk.Add(parent);
     return false;
 }
 public static XPathNavigatorReader Create(XPathNavigator navToRead)
 {
     XPathNavigator navigator = navToRead.Clone();
     IXmlLineInfo xli = navigator as IXmlLineInfo;
     IXmlSchemaInfo xsi = navigator as IXmlSchemaInfo;
     if (xsi == null)
     {
         return new XPathNavigatorReader(navigator, xli, xsi);
     }
     return new XPathNavigatorReaderWithSI(navigator, xli, xsi);
 }
 public override XPathNavigator MatchNode(XPathNavigator context) {
     if (context != null) {
         if (context.NodeType == XPathNodeType.Attribute && matches(context)) {
             XPathNavigator temp = context.Clone();
             if (temp.MoveToParent()) {
                 return qyInput.MatchNode(temp);
             }
         }
     }
     return null;
 }
 public sealed override XPathNavigator MatchNode(XPathNavigator context)
 {
     if ((context != null) && this.matches(context))
     {
         XPathNavigator current = context.Clone();
         if ((current.NodeType != XPathNodeType.Attribute) && current.MoveToParent())
         {
             return base.qyInput.MatchNode(current);
         }
     }
     return null;
 }
Example #27
0
        public override bool ParseXML(XPathNavigator node)
        {
            XPathNavigator child = node.Clone();
            base.ParseXML(child);
            if(child.MoveToChild("architecture", String.Empty))
                arch.ParseXML(child);

            child = node.Clone();
            if(child.MoveToChild("content-type", String.Empty))
                contentType = child.Value;

            child = node.Clone();
            if(child.MoveToChild("filename", String.Empty))
                filename = child.Value;

            child = node.Clone();
            if(child.MoveToChild("size", String.Empty))
                size = child.ValueAsInt;

            return true;
        }
Example #28
0
        public override XPathNavigator Advance()
        {
            if (_iterator == null)
            {
                _input = qyInput.Advance();
                if (_input == null)
                {
                    return null;
                }

                XPathNavigator prev;
                do
                {
                    prev = _input.Clone();
                    _input = qyInput.Advance();
                } while (prev.IsDescendant(_input));
                _input = prev;

                _iterator = XPathEmptyIterator.Instance;
            }

            while (!_iterator.MoveNext())
            {
                bool matchSelf;
                if (_input.NodeType == XPathNodeType.Attribute || _input.NodeType == XPathNodeType.Namespace)
                {
                    _input.MoveToParent();
                    matchSelf = false;
                }
                else
                {
                    while (!_input.MoveToNext())
                    {
                        if (!_input.MoveToParent())
                        {
                            return null;
                        }
                    }
                    matchSelf = true;
                }
                if (NameTest)
                {
                    _iterator = _input.SelectDescendants(Name, Namespace, matchSelf);
                }
                else
                {
                    _iterator = _input.SelectDescendants(TypeTest, matchSelf);
                }
            }
            position++;
            currentNode = _iterator.Current;
            return currentNode;
        }
 public XPathNavigatorReader(XPathNavigator nav)
     : base(new StringReader(""))
 {
     switch (nav.NodeType)
     {
         case XPathNodeType.Element:
         case XPathNodeType.Root:
             break;
         default:
             throw new InvalidOperationException(String.Format("NodeType {0} is not supported to read as a subtree of an XPathNavigator.", nav.NodeType));
     }
     current = nav.Clone();
 }
Example #30
0
        /// <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();
                }
            }
        }
Example #31
0
 public override ResetableIterator MakeNewCopy()
 {
     return(new XPathSelectionIterator(nav.Clone(), query.Clone()));
 }
Example #32
0
        static public XPathNavigatorReader Create(XPathNavigator navToRead)
        {
            XPathNavigator nav = navToRead.Clone();

            return(new XPathNavigatorReader(nav));
        }
        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);
        }
Example #34
0
        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 override ResetableIterator MakeNewCopy()
 {
     return(new XPathQueryIterator(query.Clone(), nav.Clone()));
 }
Example #36
0
        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);
        }
Example #37
0
 internal override void setContext(XPathNavigator e)
 {
     reset();
     qy1.setContext(e.Clone());
     qy2.setContext(e.Clone());
 }
Example #38
0
 internal override void setContext(XPathNavigator context)
 {
     reset();
     base.setContext(context);
     _context = context.Clone();
 }
        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 SimpleIterator(XPathNavigator nav, NSResolver nsm) : base(nsm)
 {
     _nav = nav.Clone();
 }
Example #41
0
        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;
                }
            }
        }
Example #42
0
        private void InvokeFunction(XPathNavigator qy)
        {
            IXsltContextFunction function = this.Function;

            // calculate arguments:
            Debug.Assert(_ArgArray != null && _ArgArray.Length == _ArgList.Count);
            for (int i = _ArgList.Count - 1; 0 <= i; i--)
            {
                IQuery arg = (IQuery)_ArgList[i];
                if (arg.ReturnType() == XPathResultType.NodeSet)
                {
                    _ArgArray[i] = new XPathQueryIterator(arg, qy.Clone());
                }
                else
                {
                    _ArgArray[i] = arg.getValue(qy, null);
                }
            }

            try {
                object result = function.Invoke(_XsltContext, _ArgArray, qy);

                if (result == null)
                {
                    _ResultQuery = new OperandQuery(String.Empty, XPathResultType.String);
                }
                else
                {
                    XPathResultType returnedType = function.ReturnType;
                    if (returnedType == XPathResultType.Any)
                    {
                        // If function is untyped get returned type from real result
                        returnedType = XsltCompileContext.GetXPathType(result.GetType());
                    }
                    switch (returnedType)
                    {
                    case XPathResultType.String:
                        // trick. As soon XPathResultType.Navigator will be distinct type rid of from it.
                        //_ResultQuery = new OperandQuery( result, XPathResultType.String );
                        if (result is XPathNavigator)
                        {
                            _ResultQuery = new NavigatorQuery((XPathNavigator)result);
                        }
                        else
                        {
                            _ResultQuery = new OperandQuery(result, XPathResultType.String);
                        }
                        break;

                    case XPathResultType.Boolean:
                        _ResultQuery = new OperandQuery(result, XPathResultType.Boolean);
                        break;

                    case XPathResultType.Number:
                        _ResultQuery = new OperandQuery(XmlConvert.ToXPathDouble(result), XPathResultType.Number);
                        break;

                    case XPathResultType.NodeSet:
                        if (result is ResetableIterator)
                        {
                            _ResultQuery = new XmlIteratorQuery((ResetableIterator)result);
                        }
                        else
                        {
                            Debug.Assert(false, "Unexpected type of XPathNodeIterator");
                            throw new NotSupportedException(Res.GetString(Res.XmlUnsupportedType, result.GetType().FullName));
                        }
                        break;

//                  case XPathResultType.Navigator :
//                      _ResultQuery = new NavigatorQuery((XPathNavigator)result);
//                      break;
                    default:
                        _ResultQuery = new OperandQuery(result.ToString(), XPathResultType.String);
                        break;
                    }
                }
            }
            catch (Exception ex) {
                string qname = _Prefix != string.Empty ? _Prefix + ":" + _Name : _Name;
                throw new XsltException(Res.Xslt_FunctionFailed, new string[] { qname }, ex);
            }
        }
Example #43
0
        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);
        }
        internal override XPathNavigator advance()
        {
            while (true)
            {
                if (m_eNext == null)
                {
                    if (_ElementStk.Count == 0)
                    {
                        if (_NextInput == null)
                        {
                            while ((m_eNext = m_qyInput.advance()) != null)
                            {
                                if (NotVisited(m_eNext))
                                {
                                    break;
                                }
                            }
                            if (m_eNext != null)
                            {
                                m_eNext = m_eNext.Clone();
                            }
                            else
                            {
                                return(null);
                            }
                        }
                        else
                        {
                            m_eNext    = _NextInput;
                            _NextInput = null;
                        }
                    }
                    else
                    {
                        m_eNext = _ElementStk.Pop() as XPathNavigator;
                    }
                }

                if (_NextInput == null)
                {
                    while ((_NextInput = m_qyInput.advance()) != null)
                    {
                        if (NotVisited(_NextInput))
                        {
                            break;
                        }
                    }
                    if (_NextInput != null)
                    {
                        _NextInput = _NextInput.Clone();
                    }
                }

                if (_NextInput != null)
                {
                    while (m_eNext.IsDescendant(_NextInput))
                    {
                        _ElementStk.Push(m_eNext);
                        m_eNext    = _NextInput;
                        _NextInput = m_qyInput.advance();
                        if (_NextInput != null)
                        {
                            _NextInput = _NextInput.Clone();
                        }
                    }
                }

                while (m_eNext.MoveToNext())
                {
                    if (matches(m_eNext))
                    {
                        _position++;
                        return(m_eNext);
                    }
                }
                m_eNext = null;
            }
            //return null;
        } // Advance
Example #45
0
 public SimpleIterator(XPathNavigator nav, IXmlNamespaceResolver nsm) : base(nsm)
 {
     this._nav = nav.Clone();
 }
Example #46
0
        public override string GetAttribute(string name)
        {
            // reader allows calling GetAttribute, even when positioned inside attributes
            XPathNavigator nav = _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)_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)_nav)
                {
                    nav = nav.Clone();
                }
                if (nav.MoveToFirstAttribute())
                {
                    do
                    {
                        if (nav.LocalName == localname && nav.Prefix == prefix)
                        {
                            return(nav.Value);
                        }
                    } while (nav.MoveToNextAttribute());
                }
            }
            return(null);
        }
Example #47
0
 /// <summary>See <see cref="IMatchedNodes.AddMatched"/>.</summary>
 public void AddMatched(System.Xml.XPath.XPathNavigator node)
 {
     _matched.Add(node.Clone());
 }
Example #48
0
        public override bool MoveToNextAttribute()
        {
            switch (_state)
            {
            case State.Content:
                return(MoveToFirstAttribute());

            case State.Attribute:
            {
                if (XPathNodeType.Attribute == _nav.NodeType)
                {
                    return(_nav.MoveToNextAttribute());
                }

                // otherwise it is on a namespace... namespace are in reverse order
                Debug.Assert(XPathNodeType.Namespace == _nav.NodeType);
                XPathNavigator nav = _nav.Clone();
                if (!nav.MoveToParent())
                {
                    return(false);        // shouldn't happen
                }
                if (!nav.MoveToFirstNamespace(XPathNamespaceScope.Local))
                {
                    return(false);        // shouldn't happen
                }
                if (nav.IsSamePosition(_nav))
                {
                    // this was the last one... start walking attributes
                    nav.MoveToParent();
                    if (!nav.MoveToFirstAttribute())
                    {
                        return(false);
                    }
                    // otherwise we are there
                    _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(_nav))
                        {
                            _nav.MoveTo(prev);
                            return(true);
                        }
                        prev.MoveTo(nav);
                    }
                    // found previous namespace position
                }
            }

            case State.AttrVal:
                _depth--;
                _state = State.Attribute;
                if (!MoveToNextAttribute())
                {
                    _depth++;
                    _state = State.AttrVal;
                    return(false);
                }
                _nodeType = XmlNodeType.Attribute;
                return(true);

            case State.InReadBinary:
                _state = _savedState;
                if (!MoveToNextAttribute())
                {
                    _state = State.InReadBinary;
                    return(false);
                }
                _readBinaryHelper.Finish();
                return(true);

            default:
                return(false);
            }
        }
Example #49
0
        internal override XPathNavigator advance()
        {
            switch (m_qyInput.ReturnType())
            {
            case XPathResultType.NodeSet:
                if (ElementList == null)
                {
                    ElementList = new ArrayList();
                    XPathNavigator temp;
                    while ((temp = m_qyInput.advance()) != null)
                    {
                        if (_context.MoveToId(temp.Value))
                        {
                            AddToStack(_context.Clone());
                        }
                    }
                    strcount = ElementList.Count;
                }
                Debug.Assert(strcount >= 0);
                if (strcount != 0)
                {
                    return(ElementList[--strcount] as XPathNavigator);
                }
                return(null);

            case XPathResultType.String:
                if (ElementList == null)
                {
                    String   str = (String)m_qyInput.getValue(_context, null);                        char[] a = { ' ' };
                    String[] strarray = str.Split(null);
                    ElementList = new ArrayList();
                    while (strcount < strarray.Length)
                    {
                        if (_context.MoveToId(strarray[strcount++]))
                        {
                            AddToStack(_context.Clone());
                        }
                    }
                    strcount = ElementList.Count;
                }
                Debug.Assert(strcount >= 0);

                if (strcount != 0)
                {
                    return(ElementList[--strcount] as XPathNavigator);
                }
                return(null);

            case XPathResultType.Number:
                if (strcount == 0 && _context.MoveToId(StringFunctions.toString((double)m_qyInput.getValue(_context, null))))
                {
                    strcount = 1;
                    return(_context);
                }
                else
                {
                    return(null);
                }

            case XPathResultType.Boolean:
                if (strcount == 0 && _context.MoveToId(StringFunctions.toString((Boolean)m_qyInput.getValue(_context, null))))
                {
                    strcount = 1;
                    return(_context);
                }
                else
                {
                    return(null);
                }
            }
            return(null);
        } // Advance
        internal override object getValue(XPathNavigator qyContext, XPathNodeIterator iterator)
        {
            XPathNavigator eNext;

            switch (_FType)
            {
            case FT.FuncPosition:
                if (iterator != null)
                {
                    return((double)iterator.CurrentPosition);
                }
                return((double)0);

            case FT.FuncNameSpaceUri:
                if (_Opnd != null)
                {
                    _Opnd.setContext(qyContext.Clone());
                    if ((eNext = _Opnd.advance()) != null)
                    {
                        return(eNext.NamespaceURI);
                    }
                    else
                    {
                        return(String.Empty);
                    }
                }
                if (qyContext != null)
                {
                    return(qyContext.NamespaceURI);
                }

                return(String.Empty);

            case FT.FuncLocalName:
                if (_Opnd != null)
                {
                    _Opnd.setContext(qyContext.Clone());
                    if ((eNext = _Opnd.advance()) != null)
                    {
                        return(eNext.LocalName);
                    }
                    else
                    {
                        return(String.Empty);
                    }
                }
                if (qyContext != null)
                {
                    return(qyContext.LocalName);
                }

                return(String.Empty);

            case FT.FuncName:
                if (_Opnd != null)
                {
                    _Opnd.setContext(qyContext.Clone());
                    if ((eNext = _Opnd.advance()) != null)
                    {
                        return(eNext.Name);
                    }
                    else
                    {
                        return(String.Empty);
                    }
                }
                if (qyContext != null)
                {
                    return(qyContext.Name);
                }
                return(String.Empty);

            case FT.FuncCount:
                int i = 0;
                _Opnd.setContext(qyContext.Clone());
                if (checkWhitespace)
                {
                    XPathNavigator nav;
                    while ((nav = _Opnd.advance()) != null)
                    {
                        if (nav.NodeType != XPathNodeType.Whitespace || context.PreserveWhitespace(nav))
                        {
                            i++;
                        }
                    }
                    return((double)i);
                }
                while (_Opnd.advance() != null)
                {
                    i++;
                }
                return((double)i);

            case FT.FuncLast:
                if (iterator != null)
                {
                    return((double)iterator.Count);
                }
                else
                {
                    return((double)0);
                }
            }
            return(String.Empty);
        }
Example #51
0
        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();
                    }
                }
            }
        }