コード例 #1
0
ファイル: XmlEditorNavigator.cs プロジェクト: renyh1013/dp2
		public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
		{
			//StreamUtil.WriteText("I:\\debug.txt","进到 MoveToNextNamespace()\r\n");
            Debug.Assert(this.m_navigatorState.CurItem != null, "");


            if (this.m_navigatorState.CurItem == this.m_navigatorState.VirtualRoot)
				return false;

            if (!(this.m_navigatorState.CurItem is AttrItem))
				return false;

            AttrItem attr = (AttrItem)this.m_navigatorState.CurItem;

			if (attr.IsNamespace == false)
				return false;

			ElementItem element = (ElementItem)attr.parent;

			ItemList namespaceList = element.NamespaceList;
			if (namespaceList.Count > 0)
			{
                int nIndex = namespaceList.IndexOf(this.m_navigatorState.CurItem);
				if (nIndex == -1)
					return false;
				if (nIndex + 1 >= namespaceList.Count)
					return false;

                this.m_navigatorState.CurItem = namespaceList[nIndex + 1];
				return true;
			}

			return false;
		}
コード例 #2
0
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     return(_decoratedNavigator.MoveToNextNamespace(namespaceScope));
 }
コード例 #3
0
 public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
 {
     return false;
 }
コード例 #4
0
 public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
 {
     this.IncrementNodeCount();
     return this.navigator.MoveToFirstNamespace(namespaceScope);
 }
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     this.currentPosition = -1L;
     return this.navigator.MoveToNextNamespace(namespaceScope);
 }
コード例 #6
0
ファイル: XmlDocumentNavigator.cs プロジェクト: nobled/mono
		public override bool MoveToNextNamespace (XPathNamespaceScope namespaceScope)
		{
			if (NsNode == Document.NsNodeXml)
				// Current namespace is "xml", so there should be no more namespace nodes.
				return false;

			if (NsNode == null)
				return false;

			// Get current attribute's position.
			int pos = 0;
			XmlElement owner = ((XmlAttribute) NsNode).OwnerElement;
			if (owner == null)
				return false;

			int count = owner.Attributes.Count;
			for(; pos < count; pos++)
				if (owner.Attributes [pos] == NsNode)
					break;
			if (pos == count)
				return false;	// Where is current attribute? Maybe removed.

			// Find next namespace from the same element as current ns node.
			for(pos++; pos < count; pos++) {
				if (owner.Attributes [pos].NamespaceURI == Xmlns) {
					XmlAttribute a = owner.Attributes [pos];
					if (CheckNsNameAppearance (a.Name, a.Value))
						continue;
					NsNode = a;
					return true;
				}
			}

			// If not found more, then find from ancestors.
			// But if scope is Local, then it returns false here.
			if (namespaceScope == XPathNamespaceScope.Local)
				return false;
			owner = GetParentNode (owner) as XmlElement;
			while (owner != null) {
				if (owner.HasAttributes) {
					for (int i = 0; i < owner.Attributes.Count; i++) {
						XmlAttribute attr = owner.Attributes [i];
						if (attr.NamespaceURI == Xmlns) {
							if (CheckNsNameAppearance (attr.Name, attr.Value))
								continue;
							NsNode = attr;
							return true;
						}
					}
				}
				owner = GetParentNode (owner) as XmlElement;
			}

			if (namespaceScope == XPathNamespaceScope.All) {
				if (CheckNsNameAppearance (Document.NsNodeXml.Name, Document.NsNodeXml.Value))
					return false;
				NsNode = Document.NsNodeXml;
				return true;
			}
			return false;
		}
コード例 #7
0
 public abstract NavigatorAdapter MoveToFirstNamespace(XPathNamespaceScope namespaceScope);        
コード例 #8
0
 /// <inheritdoc />
 public override Boolean MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     return(false);
 }
コード例 #9
0
 /// <summary>
 ///     Moves the XPathNavigator to the next namespace node matching the XPathNamespaceScope specified.
 /// </summary>
 /// <param name="namespaceScope">An XPathNamespaceScope value describing the namespace scope. </param>
 /// <returns>
 ///     Returns true if the XPathNavigator is successful moving to the next namespace node;
 ///     otherwise, false. If false, the position of the XPathNavigator is unchanged.
 /// </returns>
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     DebugEnter("MoveToNextNamespace");
     DebugReturn(false);
     return(false);
 }
コード例 #10
0
        public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
        {
            if (this.NsNode == this.Document.NsNodeXml)
            {
                return(false);
            }
            if (this.NsNode == null)
            {
                return(false);
            }
            int        i          = 0;
            XmlElement xmlElement = this.NsNode.OwnerElement;

            if (xmlElement == null)
            {
                return(false);
            }
            int count = xmlElement.Attributes.Count;

            while (i < count)
            {
                if (xmlElement.Attributes[i] == this.NsNode)
                {
                    break;
                }
                i++;
            }
            if (i == count)
            {
                return(false);
            }
            for (i++; i < count; i++)
            {
                if (xmlElement.Attributes[i].NamespaceURI == "http://www.w3.org/2000/xmlns/")
                {
                    XmlAttribute xmlAttribute = xmlElement.Attributes[i];
                    if (!this.CheckNsNameAppearance(xmlAttribute.Name, xmlAttribute.Value))
                    {
                        this.NsNode = xmlAttribute;
                        return(true);
                    }
                }
            }
            if (namespaceScope == XPathNamespaceScope.Local)
            {
                return(false);
            }
            for (xmlElement = (this.GetParentNode(xmlElement) as XmlElement); xmlElement != null; xmlElement = (this.GetParentNode(xmlElement) as XmlElement))
            {
                if (xmlElement.HasAttributes)
                {
                    for (int j = 0; j < xmlElement.Attributes.Count; j++)
                    {
                        XmlAttribute xmlAttribute2 = xmlElement.Attributes[j];
                        if (xmlAttribute2.NamespaceURI == "http://www.w3.org/2000/xmlns/")
                        {
                            if (!this.CheckNsNameAppearance(xmlAttribute2.Name, xmlAttribute2.Value))
                            {
                                this.NsNode = xmlAttribute2;
                                return(true);
                            }
                        }
                    }
                }
            }
            if (namespaceScope != XPathNamespaceScope.All)
            {
                return(false);
            }
            if (this.CheckNsNameAppearance(this.Document.NsNodeXml.Name, this.Document.NsNodeXml.Value))
            {
                return(false);
            }
            this.NsNode = this.Document.NsNodeXml;
            return(true);
        }
コード例 #11
0
 public override bool MoveToNextNamespace(XPathNamespaceScope scope)
 {
     return(navigator.MoveToNextNamespace(scope));
 }
コード例 #12
0
        public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
        {
            logger.Trace("MoveToNextNamespace");

            return(false);
        }
コード例 #13
0
 public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope) => default; // 0x00000001806134E0-0x0000000180613780
 public override bool MoveToNextNamespace(XPathNamespaceScope scope) => default;           // 0x0000000180613780-0x0000000180613990
コード例 #14
0
 public override XPathNavigator Clone() => default;                                        // 0x0000000180613360-0x0000000180613440
 public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope) => default; // 0x00000001806134E0-0x0000000180613780
コード例 #15
0
 //Moves to the next namespace node depending upon the namespace scope.
 public override bool MoveToNextNamespace( XPathNamespaceScope nsScope ) {
     //Navigator should be on a Namespace node when this is called.
     if ( ( _curNode.NodeType != XmlNodeType.Attribute ) || ( ! ( Ref.Equal(_curNode.NamespaceURI, XmlDocument.strReservedXmlns) ) ) )
         return false;
     if( nsScope == XPathNamespaceScope.Local ) {
         XmlAttribute attr = _curNode as XmlAttribute;
         if( _curNode == null )
             return false;
         _curNode = attr.OwnerElement;
         if( _curNode == null )
             return false;
         //Navigator is no more in local scope if the following 
         //condition is satisfied.
         if( _curNode != _parentOfNS )
             return false;
         return MoveToNextLocalNamespace( _curNode, _attrInd );
     }
     else if( nsScope == XPathNamespaceScope.ExcludeXml )
         return MoveToNextNonXmlNamespace();                
     else if( nsScope == XPathNamespaceScope.All ) {
         XmlNode temp = ((XmlAttribute)_curNode).OwnerElement;
         if( temp == null )
             return false;
         if( MoveToNextNonXmlNamespace() )
             return true;
         _curNode = attrXmlNS;
         return true;                 
     }
     else
         return false;
 }
コード例 #16
0
 /// <include file='doc\XPathNavigator.uex' path='docs/doc[@for="XPathNavigator.MoveToFirstNamespace1"]/*' />
 public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
 {
     return(_xn.MoveToFirstNamespace(namespaceScope));
 }
コード例 #17
0
        /// <summary>
        /// Position the navigator on the next namespace within the specified scope.  If no matching namespace
        /// can be found, return false.
        /// </summary>
        public override bool MoveToNextNamespace(XPathNamespaceScope scope)
        {
            XPathNode[] page = _pageCurrent, pageParent;
            int idx = _idxCurrent, idxParent;

            // If current node is not a namespace node, return false
            if (page[idx].NodeType != XPathNodeType.Namespace)
                return false;

            while (true)
            {
                // Get next namespace sibling
                idx = page[idx].GetSibling(out page);

                // If there are no more nodes, return false
                if (idx == 0)
                    return false;

                switch (scope)
                {
                    case XPathNamespaceScope.Local:
                        // Once parent changes, there are no longer any local namespaces
                        idxParent = page[idx].GetParent(out pageParent);
                        if (idxParent != _idxParent || (object)pageParent != (object)_pageParent)
                            return false;
                        break;

                    case XPathNamespaceScope.ExcludeXml:
                        // If node is xmlns:xml, then skip it
                        if (page[idx].IsXmlNamespaceNode)
                            continue;
                        break;
                }

                // Found a matching next namespace node, so return it
                break;
            }

            _pageCurrent = page;
            _idxCurrent = idx;
            return true;
        }
コード例 #18
0
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope) => _inner.MoveToNextNamespace(namespaceScope);
コード例 #19
0
		public override bool MoveToNextNamespace (XPathNamespaceScope scope)
		{
			if (attr == null)
				return false;
			for (XAttribute a = attr.NextAttribute; a != null; a = a.NextAttribute)
				if (a.IsNamespaceDeclaration) {
					attr = a;
					return true;
				}

			if (scope == XPathNamespaceScope.Local)
				return false;

			for (XElement el = ((XElement) attr.Parent).Parent; el != null; el = el.Parent) {
				foreach (XAttribute a in el.Attributes ())
					if (a.IsNamespaceDeclaration) {
						attr = a;
						return true;
					}
			}
			if (scope != XPathNamespaceScope.All)
				return false;
			attr = attr_ns_xml;
			return true;
		}
コード例 #20
0
 /// <summary>
 /// See <see cref="XPathNavigator.MoveToNextNamespace(XPathNamespaceScope)"/>.
 /// </summary>
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     return(nav.MoveToNextNamespace(namespaceScope));
 }
コード例 #21
0
ファイル: DTMXPathNavigator.cs プロジェクト: REALTOBIZ/mono
		public override bool MoveToFirstNamespace (
			XPathNamespaceScope namespaceScope)
		{
			if (!currentIsNode)
				return false;
			int cur = nodes [currentNode].FirstNamespace;
			return moveToSpecifiedNamespace (cur, namespaceScope);
		}
コード例 #22
0
        /// <summary>
        /// Copy the navigator subtree to the raw writer.
        /// </summary>
        private void CopyNode(XPathNavigator nav)
        {
            XPathNodeType nodeType;
            int           iLevel = 0;

            while (true)
            {
                if (CopyShallowNode(nav))
                {
                    nodeType = nav.NodeType;
                    if (nodeType == XPathNodeType.Element)
                    {
                        // Copy attributes
                        if (nav.MoveToFirstAttribute())
                        {
                            do
                            {
                                CopyShallowNode(nav);
                            }while (nav.MoveToNextAttribute());
                            nav.MoveToParent();
                        }

                        // Copy namespaces in document order (navigator returns them in reverse document order)
                        XPathNamespaceScope nsScope = (iLevel == 0) ? XPathNamespaceScope.ExcludeXml : XPathNamespaceScope.Local;
                        if (nav.MoveToFirstNamespace(nsScope))
                        {
                            CopyNamespaces(nav, nsScope);
                            nav.MoveToParent();
                        }

                        _xwrt.StartElementContent();
                    }

                    // If children exist, move down to next level
                    if (nav.MoveToFirstChild())
                    {
                        iLevel++;
                        continue;
                    }
                    else
                    {
                        // EndElement
                        if (nav.NodeType == XPathNodeType.Element)
                        {
                            _xwrt.WriteEndElement(nav.Prefix, nav.LocalName, nav.NamespaceURI);
                        }
                    }
                }

                // No children
                while (true)
                {
                    if (iLevel == 0)
                    {
                        // The entire subtree has been copied
                        return;
                    }

                    if (nav.MoveToNext())
                    {
                        // Found a sibling, so break to outer loop
                        break;
                    }

                    // No siblings, so move up to previous level
                    iLevel--;
                    nav.MoveToParent();

                    // EndElement
                    if (nav.NodeType == XPathNodeType.Element)
                    {
                        _xwrt.WriteFullEndElement(nav.Prefix, nav.LocalName, nav.NamespaceURI);
                    }
                }
            }
        }
コード例 #23
0
 public override bool MoveToNextNamespace(XPathNamespaceScope scope)
 {
     return false;
 }
コード例 #24
0
ファイル: XmlNodeNavigator.cs プロジェクト: zanyants/mvp.xml
 /// <summary>See <see cref="XPathNavigator.MoveToFirstNamespace"/></summary>
 public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
 {
     return(_state.AtRoot? false: _state.Navigator.MoveToFirstNamespace(namespaceScope));
 }
コード例 #25
0
 public override bool MoveToFirstNamespace(XPathNamespaceScope scope)
 {
     XmlElement element = _source as XmlElement;
     if (element == null)
     {
         return false;
     }
     XmlAttributeCollection attributes;
     int index = Int32.MaxValue;
     switch (scope)
     {
         case XPathNamespaceScope.Local:
             if (!element.HasAttributes)
             {
                 return false;
             }
             attributes = element.Attributes;
             if (!MoveToFirstNamespaceLocal(attributes, ref index))
             {
                 return false;
             }
             _source = attributes[index];
             _attributeIndex = index;
             _namespaceParent = element;
             break;
         case XPathNamespaceScope.ExcludeXml:
             attributes = element.Attributes;
             if (!MoveToFirstNamespaceGlobal(ref attributes, ref index, element))
             {
                 return false;
             }
             XmlAttribute attribute = attributes[index];
             while (Ref.Equal(attribute.LocalName, XmlConst.NsXml))
             {
                 if (!MoveToNextNamespaceGlobal(ref attributes, ref index, element))
                 {
                     return false;
                 }
                 attribute = attributes[index];
             }
             _source = attribute;
             _attributeIndex = index;
             _namespaceParent = element;
             break;
         case XPathNamespaceScope.All:
             attributes = element.Attributes;
             if (!MoveToFirstNamespaceGlobal(ref attributes, ref index, element))
             {
                 _source = _document.GetNamespaceXml();
                 // attributeIndex = 0;
             }
             else
             {
                 _source = attributes[index];
                 _attributeIndex = index;
             }
             _namespaceParent = element;
             break;
         default:
             Debug.Assert(false);
             return false;
     }
     return true;
 }
コード例 #26
0
 /// <include file='doc\XPathNavigator.uex' path='docs/doc[@for="XPathNavigator.MoveToNextNamespace1"]/*' />
 public abstract bool MoveToNextNamespace(XPathNamespaceScope namespaceScope);
コード例 #27
0
        /// <summary>
        /// Copy all or some (which depends on nsScope) of the namespaces on the navigator's current node to the
        /// raw writer.
        /// </summary>
        private void CopyNamespaces(XPathNavigator nav, XPathNamespaceScope nsScope) {
            string prefix = nav.LocalName;
            string ns = nav.Value;

            if (nav.MoveToNextNamespace(nsScope)) {
                CopyNamespaces(nav, nsScope);
            }

            this.xwrt.WriteNamespaceDeclaration(prefix, ns);
        }
コード例 #28
0
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     throw new NotSupportedException();
 }
コード例 #29
0
ファイル: XmlEditorNavigator.cs プロジェクト: renyh1013/dp2
		public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
		{

			//StreamUtil.WriteText("I:\\debug.txt","进到 MoveToFirstNamespace()\r\n");

            if (!(this.m_navigatorState.CurItem is ElementItem))
				return false;

            ElementItem element = (ElementItem)this.m_navigatorState.CurItem;

			ItemList namespaceList = element.NamespaceList;
			if (namespaceList.Count > 0)
			{
                this.m_navigatorState.CurItem = namespaceList[0];
				return true;
			}

			return false;
		}
コード例 #30
0
 public override bool MoveToFirstNamespace(XPathNamespaceScope scope)
 {
     this.InternalTrace(null);
     return(false);
 }
コード例 #31
0
 //Moves to the first namespace node depending upon the namespace scope.
 public override bool MoveToFirstNamespace( XPathNamespaceScope nsScope ) { 
     if( nsScope == XPathNamespaceScope.Local ) {
         XmlElement _parentOfNS = _curNode as XmlElement;
         if( _parentOfNS == null )
             return false;
         if( MoveToFirstLocalNamespace( _curNode ) )
             return true;
         else {
             _parentOfNS = null;
             return false;
         }                    
     }
     else if( nsScope == XPathNamespaceScope.ExcludeXml )
         return MoveToFirstNonXmlNamespace();                
     else if( nsScope == XPathNamespaceScope.All ) {                
         _parentOfNS = _curNode as XmlElement;
         XmlElement cache = _parentOfNS;
         if( _parentOfNS == null )
             return false;
         if( MoveToFirstNonXmlNamespace() )
             return true;
         _parentOfNS = cache;
         _curNode = attrXmlNS;
         return true;
     }
     else return false;
 }
コード例 #32
0
 /// <summary>
 /// See <see cref="XPathNavigator.MoveToNextNamespace(XPathNamespaceScope)"/>.
 /// </summary>
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     return(AtRoot ? false : _navigator.MoveToNextNamespace(namespaceScope));
 }
コード例 #33
0
        /// <summary>
        /// Position the navigator on the namespace within the specified scope.  If no matching namespace
        /// can be found, return false.
        /// </summary>
        public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
        {
            XPathNode[] page;
            int idx;

            if (namespaceScope == XPathNamespaceScope.Local)
            {
                // Get local namespaces only
                idx = XPathNodeHelper.GetLocalNamespaces(_pageCurrent, _idxCurrent, out page);
            }
            else
            {
                // Get all in-scope namespaces
                idx = XPathNodeHelper.GetInScopeNamespaces(_pageCurrent, _idxCurrent, out page);
            }

            while (idx != 0)
            {
                // Don't include the xmlns:xml namespace node if scope is ExcludeXml
                if (namespaceScope != XPathNamespaceScope.ExcludeXml || !page[idx].IsXmlNamespaceNode)
                {
                    _pageParent = _pageCurrent;
                    _idxParent = _idxCurrent;
                    _pageCurrent = page;
                    _idxCurrent = idx;
                    return true;
                }

                // Skip past xmlns:xml
                idx = page[idx].GetSibling(out page);
            }

            return false;
        }
コード例 #34
0
 public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope)
 {
     return(false);
 }
コード例 #35
0
ファイル: XmlDocumentNavigator.cs プロジェクト: nobled/mono
		public override bool MoveToFirstNamespace (XPathNamespaceScope namespaceScope)
		{
			if (NodeType != XPathNodeType.Element)
				return false;
			XmlElement el = node as XmlElement;
			do {
				if (el.HasAttributes) {
					for (int i = 0; i < el.Attributes.Count; i++) {
						XmlAttribute attr = el.Attributes [i];
						if (attr.NamespaceURI == Xmlns) {
							if (CheckNsNameAppearance (attr.Name, attr.Value))
								continue;
							NsNode = attr;
							return true;
						}
					}
				}
				if (namespaceScope == XPathNamespaceScope.Local)
					return false;
				el = GetParentNode (el) as XmlElement;
			} while (el != null);

			if (namespaceScope == XPathNamespaceScope.All) {
				if (CheckNsNameAppearance (Document.NsNodeXml.Name, Document.NsNodeXml.Value))
					return false;
				NsNode = Document.NsNodeXml;
				return true;
			}
			else
				return false;
		}
コード例 #36
0
 public override bool MoveToNextNamespace(XPathNamespaceScope scope)
 {
     return(false);
 }
コード例 #37
0
		public override bool MoveToFirstNamespace (XPathNamespaceScope scope)
		{
			for (XElement el = node as XElement; el != null; el = el.Parent) {
				foreach (XAttribute a in el.Attributes ())
					if (a.IsNamespaceDeclaration) {
						attr = a;
						return true;
					}
				if (scope == XPathNamespaceScope.Local)
					return false;
			}
			if (scope != XPathNamespaceScope.All)
				return false;
			attr = attr_ns_xml;
			return true;
		}
コード例 #38
0
 /// <summary>
 /// Moves the XPathNavigator to the next namespace node.
 /// Always returns falsefor the HtmlNavigator implementation.
 /// </summary>
 /// <param name="scope">An XPathNamespaceScope value describing the namespace scope.</param>
 /// <returns>Always returns false for the HtmlNavigator implementation.</returns>
 public override bool MoveToNextNamespace(XPathNamespaceScope scope)
 {
     InternalTrace(null);
     return(false);
 }
コード例 #39
0
		public override bool MoveToNextNamespace (XPathNamespaceScope scope)
		{
			return navigator.MoveToNextNamespace (scope);
		}
コード例 #40
0
        public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
        {
            if (NsNode == Document.NsNodeXml)
            {
                // Current namespace is "xml", so there should be no more namespace nodes.
                return(false);
            }

            if (NsNode == null)
            {
                return(false);
            }

            // Get current attribute's position.
            int        pos   = 0;
            XmlElement owner = ((XmlAttribute)NsNode).OwnerElement;

            if (owner == null)
            {
                return(false);
            }

            int count = owner.Attributes.Count;

            for (; pos < count; pos++)
            {
                if (owner.Attributes [pos] == NsNode)
                {
                    break;
                }
            }
            if (pos == count)
            {
                return(false);                  // Where is current attribute? Maybe removed.
            }
            // Find next namespace from the same element as current ns node.
            for (pos++; pos < count; pos++)
            {
                if (owner.Attributes [pos].NamespaceURI == Xmlns)
                {
                    XmlAttribute a = owner.Attributes [pos];
                    if (CheckNsNameAppearance(a.Name, a.Value))
                    {
                        continue;
                    }
                    NsNode = a;
                    return(true);
                }
            }

            // If not found more, then find from ancestors.
            // But if scope is Local, then it returns false here.
            if (namespaceScope == XPathNamespaceScope.Local)
            {
                return(false);
            }
            owner = GetParentNode(owner) as XmlElement;
            while (owner != null)
            {
                if (owner.HasAttributes)
                {
                    for (int i = 0; i < owner.Attributes.Count; i++)
                    {
                        XmlAttribute attr = owner.Attributes [i];
                        if (attr.NamespaceURI == Xmlns)
                        {
                            if (CheckNsNameAppearance(attr.Name, attr.Value))
                            {
                                continue;
                            }
                            NsNode = attr;
                            return(true);
                        }
                    }
                }
                owner = GetParentNode(owner) as XmlElement;
            }

            if (namespaceScope == XPathNamespaceScope.All)
            {
                if (CheckNsNameAppearance(Document.NsNodeXml.Name, Document.NsNodeXml.Value))
                {
                    return(false);
                }
                NsNode = Document.NsNodeXml;
                return(true);
            }
            return(false);
        }
コード例 #41
0
ファイル: DTMXPathNavigator.cs プロジェクト: REALTOBIZ/mono
		private bool moveToSpecifiedNamespace (int cur,
			XPathNamespaceScope namespaceScope)
		{
			if (cur == 0)
				return false;

			if (namespaceScope == XPathNamespaceScope.Local &&
					namespaces [cur].DeclaredElement != currentNode)
				return false;

			if (namespaceScope != XPathNamespaceScope.All
				&& namespaces [cur].Namespace == XmlNamespaces.XML)
				return false;

			if (cur != 0) {
				moveToNamespace (cur);
				return true;
			}
			else
				return false;
		}
コード例 #42
0
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     return _adapter.MoveToNextNamespace(namespaceScope);
 }
コード例 #43
0
ファイル: DTMXPathNavigator.cs プロジェクト: REALTOBIZ/mono
		public override bool MoveToNextNamespace (
			XPathNamespaceScope namespaceScope)
		{
			if (currentIsAttr || currentIsNode)
				return false;

			int cur = namespaces [currentNs].NextNamespace;
			return moveToSpecifiedNamespace (cur, namespaceScope);
		}
コード例 #44
0
ファイル: XPathNodePointer.cs プロジェクト: ItsVeryWindy/mono
        //Caller( DataDocumentXPathNavigator will make sure that the node is at the right position for this call )
        internal bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope) {
            //Debug.WriteLineIf( XmlTrace.traceXPathNodePointerFunctions.Enabled, "XPathNodePointer:MoveToFirstNamespace(namespaceScope)");
            RealFoliate();
            _parentOfNS = this._node as XmlBoundElement;
            //only need to check with _node, even if _column is not null and its mapping type is element, it can't have attributes
            if ( _parentOfNS == null )
                return false; 
            XmlNode node = this._node;
            XmlBoundElement be = null;
            while ( node != null ) {
                be = node as XmlBoundElement;
                if ( MoveToNextNamespace( be, null, null ) )
                    return true;
                //didn't find it
                if ( namespaceScope == XPathNamespaceScope.Local )
                    goto labelNoNS;
                //try the next element anccestor.
                do {
                    node = node.ParentNode;
                } while ( node != null && node.NodeType != XmlNodeType.Element );
            }
            if ( namespaceScope == XPathNamespaceScope.All ) {
                MoveTo( this._doc.attrXml, null, false );
                return true;
            }
labelNoNS:
            //didn't find one namespace node
            _parentOfNS = null;
            return false;
        }
コード例 #45
0
 /// <summary>
 /// Moves the XPathNavigator to the next namespace node.
 /// Always returns falsefor the HtmlNavigator implementation.
 /// </summary>
 /// <param name="scope">An XPathNamespaceScope value describing the namespace scope.</param>
 /// <returns>Always returns false for the HtmlNavigator implementation.</returns>
 public override bool MoveToNextNamespace(XPathNamespaceScope scope)
 {
     InternalTrace(null);
     return false;
 }
コード例 #46
0
ファイル: XPathNodePointer.cs プロジェクト: ItsVeryWindy/mono
 //Caller( DataDocumentXPathNavigator will make sure that the node is at the right position for this call )
 internal bool MoveToNextNamespace(XPathNamespaceScope namespaceScope) {
     //Debug.WriteLineIf( XmlTrace.traceXPathNodePointerFunctions.Enabled, "XPathNodePointer:MoveToNextNamespace(namespaceScope)");
     RealFoliate();
     Debug.Assert( _parentOfNS != null );
     XmlNode node = this._node;
     //first check within the same boundelement
     if ( this._column != null ) {
         Debug.Assert( this._column.Namespace == s_strReservedXmlns );
         if ( namespaceScope == XPathNamespaceScope.Local && _parentOfNS != this._node ) //already outside scope
             return false;
         XmlBoundElement be = this._node as XmlBoundElement;
         Debug.Assert( be != null );
         DataRow curRow = be.Row;
         Debug.Assert( curRow != null );
         DataColumn curCol = PreviousColumn( curRow, this._column, true );
         while ( curCol != null ) {
             if ( curCol.Namespace == s_strReservedXmlns ) {
                 MoveTo( be, curCol, false );
                 return true;
             }
             curCol = PreviousColumn( curRow, curCol, true );
         }                
         //didn't find it in this loop
         if ( namespaceScope == XPathNamespaceScope.Local )
             return false;
         //try its ancesstor
         do {
             node = node.ParentNode;
         } while ( node != null && node.NodeType != XmlNodeType.Element );
     } 
     else  if ( this._node.NodeType == XmlNodeType.Attribute ) {
         XmlAttribute attr = (XmlAttribute)(this._node);
         Debug.Assert( attr != null );
         node = attr.OwnerElement;
         if ( node == null )
             return false;
         if ( namespaceScope == XPathNamespaceScope.Local && _parentOfNS != node ) //already outside scope
             return false;
         if ( MoveToNextNamespace( (XmlBoundElement)node, null, (XmlAttribute)attr ) )
             return true;
         //didn't find it
         if ( namespaceScope == XPathNamespaceScope.Local )
             return false;
         do {
             node = node.ParentNode;
         } while ( node != null && node.NodeType != XmlNodeType.Element );
     }
     // till now, node should be the next accesstor (bound) element of the element parent of current namespace node (attribute or data column)
     while ( node != null ) {
         //try the namespace attributes from the same element
         XmlBoundElement be = node as XmlBoundElement;
         if ( MoveToNextNamespace( be, null, null ) )
             return true;
         //no more namespace attribute under the same element
         do {
             node = node.ParentNode;
         } while ( node != null && node.NodeType == XmlNodeType.Element );
     }
     //didn't find the next namespace, thus return
     if ( namespaceScope == XPathNamespaceScope.All ) {
         MoveTo( this._doc.attrXml, null, false );
         return true;
     }
     return false;
 }
コード例 #47
0
		/// <summary>
		/// See <see cref="XPathNavigator.MoveToNextNamespace"/>.
		/// </summary>
		public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope) 
		{
			return AtRoot ? false : _navigator.MoveToNextNamespace(namespaceScope);
		}
コード例 #48
0
        /// <summary>
        /// Copy all namespaces of the specified type (in-scope, exclude-xml, local) in document order to output.
        /// </summary>
        private void CopyNamespaces(XPathNavigator navigator, XPathNamespaceScope nsScope) {
            Debug.Assert(navigator.NodeType == XPathNodeType.Element, "Only elements have namespaces to copy");

            // Default namespace undeclaration isn't included in navigator's namespace list, so add it now
            if (navigator.NamespaceURI.Length == 0) {
                Debug.Assert(navigator.LocalName.Length != 0, "xmlns:foo='' isn't allowed");
                WriteNamespaceDeclarationUnchecked(string.Empty, string.Empty);
            }

            // Since the namespace list is arranged in reverse-document order, recursively reverse it.
            if (navigator.MoveToFirstNamespace(nsScope)) {
                CopyNamespacesHelper(navigator, nsScope);
                navigator.MoveToParent();
            }
        }
コード例 #49
0
		public abstract bool MoveToNextNamespace (XPathNamespaceScope namespaceScope);
コード例 #50
0
        /// <summary>
        /// Recursive helper function that reverses order of the namespaces retrieved by MoveToFirstNamespace and
        /// MoveToNextNamespace.
        /// </summary>
        private void CopyNamespacesHelper(XPathNavigator navigator, XPathNamespaceScope nsScope) {
            string prefix = navigator.LocalName;
            string ns = navigator.Value;

            if (navigator.MoveToNextNamespace(nsScope))
                CopyNamespacesHelper(navigator, nsScope);

            // No possibility for conflict, since we're copying namespaces from well-formed element
            WriteNamespaceDeclarationUnchecked(prefix, ns);
        }
コード例 #51
0
 public override bool MoveToNextNamespace(XPathNamespaceScope scope)
 {
     XmlAttribute attribute = _source as XmlAttribute;
     if (attribute == null
         || !attribute.IsNamespace())
     {
         return false;
     }
     XmlAttributeCollection attributes;
     int index = _attributeIndex;
     if (!CheckAttributePosition(attribute, out attributes, index)
         && !ResetAttributePosition(attribute, attributes, out index))
     {
         return false;
     }
     Debug.Assert(_namespaceParent != null);
     switch (scope)
     {
         case XPathNamespaceScope.Local:
             if (attribute.OwnerElement != _namespaceParent)
             {
                 return false;
             }
             if (!MoveToNextNamespaceLocal(attributes, ref index))
             {
                 return false;
             }
             _source = attributes[index];
             _attributeIndex = index;
             break;
         case XPathNamespaceScope.ExcludeXml:
             string localName;
             do
             {
                 if (!MoveToNextNamespaceGlobal(ref attributes, ref index, attribute.OwnerElement))
                 {
                     return false;
                 }
                 attribute = attributes[index];
                 localName = attribute.LocalName;
             }
             while (PathHasDuplicateNamespace(attribute.OwnerElement, _namespaceParent, localName)
                    || Ref.Equal(localName, XmlConst.NsXml));
             _source = attribute;
             _attributeIndex = index;
             break;
         case XPathNamespaceScope.All:
             do
             {
                 if (!MoveToNextNamespaceGlobal(ref attributes, ref index, attribute.OwnerElement))
                 {
                     if (PathHasDuplicateNamespace(null, _namespaceParent, XmlConst.NsXml))
                     {
                         return false;
                     }
                     else
                     {
                         _source = _document.GetNamespaceXml();
                         // attributeIndex = 0;
                         return true;
                     }
                 }
                 attribute = attributes[index];
             }
             while (PathHasDuplicateNamespace(attribute.OwnerElement, _namespaceParent, attribute.LocalName));
             _source = attribute;
             _attributeIndex = index;
             break;
         default:
             Debug.Assert(false);
             return false;
     }
     return true;
 }
コード例 #52
0
 public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope)
 {
     // TODO: Need to figure out what this is doing
     return(false);
 }