The Labs \ Source Viewer \ SSCLI \ System.Xml.Xsl.XsltOld \ NavigatorInput

  1. //------------------------------------------------------------------------------
  2. // <copyright file="NavigatorInput.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Xml.Xsl.XsltOld
  16. {
  17.     using Res = System.Xml.Utils.Res;
  18.     using System;
  19.     using System.Diagnostics;
  20.     using System.Xml;
  21.     using System.Xml.XPath;
  22.    
  23.     internal class NavigatorInput
  24.     {
  25.         private XPathNavigator _Navigator;
  26.         private PositionInfo _PositionInfo;
  27.         private InputScopeManager _Manager;
  28.         private NavigatorInput _Next;
  29.         private string _Href;
  30.         private Keywords _Atoms;
  31.        
  32.         internal NavigatorInput Next {
  33.             get { return _Next; }
  34.             set { _Next = value; }
  35.         }
  36.        
  37.         internal string Href {
  38.             get { return _Href; }
  39.         }
  40.        
  41.         internal Keywords Atoms {
  42.             get { return _Atoms; }
  43.         }
  44.        
  45.         internal XPathNavigator Navigator {
  46.             get {
  47.                 AssertInput();
  48.                 return _Navigator;
  49.             }
  50.         }
  51.        
  52.         internal InputScopeManager InputScopeManager {
  53.             get {
  54.                 AssertInput();
  55.                 return _Manager;
  56.             }
  57.         }
  58.        
  59.         internal bool Advance()
  60.         {
  61.             AssertInput();
  62.             return _Navigator.MoveToNext();
  63.         }
  64.        
  65.         internal bool Recurse()
  66.         {
  67.             AssertInput();
  68.             return _Navigator.MoveToFirstChild();
  69.         }
  70.        
  71.         internal bool ToParent()
  72.         {
  73.             AssertInput();
  74.             return _Navigator.MoveToParent();
  75.         }
  76.        
  77.         internal void Close()
  78.         {
  79.             _Navigator = null;
  80.             _PositionInfo = null;
  81.         }
  82.        
  83.         //
  84.         // Input document properties
  85.         //
  86.        
  87.         //
  88.         // XPathNavigator does not support line and position numbers
  89.         //
  90.        
  91.         internal int LineNumber {
  92.             get { return _PositionInfo.LineNumber; }
  93.         }
  94.        
  95.         internal int LinePosition {
  96.             get { return _PositionInfo.LinePosition; }
  97.         }
  98.        
  99.         internal XPathNodeType NodeType {
  100.             get {
  101.                 AssertInput();
  102.                 return _Navigator.NodeType;
  103.             }
  104.         }
  105.        
  106.         internal string Name {
  107.             get {
  108.                 AssertInput();
  109.                 return _Navigator.Name;
  110.             }
  111.         }
  112.        
  113.         internal string LocalName {
  114.             get {
  115.                 AssertInput();
  116.                 return _Navigator.LocalName;
  117.             }
  118.         }
  119.        
  120.         internal string NamespaceURI {
  121.             get {
  122.                 AssertInput();
  123.                 return _Navigator.NamespaceURI;
  124.             }
  125.         }
  126.        
  127.         internal string Prefix {
  128.             get {
  129.                 AssertInput();
  130.                 return _Navigator.Prefix;
  131.             }
  132.         }
  133.        
  134.         internal string Value {
  135.             get {
  136.                 AssertInput();
  137.                 return _Navigator.Value;
  138.             }
  139.         }
  140.        
  141.         internal bool IsEmptyTag {
  142.             get {
  143.                 AssertInput();
  144.                 return _Navigator.IsEmptyElement;
  145.             }
  146.         }
  147.        
  148.         internal string BaseURI {
  149.             get { return _Navigator.BaseURI; }
  150.         }
  151.        
  152.         internal bool MoveToFirstAttribute()
  153.         {
  154.             AssertInput();
  155.             return _Navigator.MoveToFirstAttribute();
  156.         }
  157.        
  158.         internal bool MoveToNextAttribute()
  159.         {
  160.             AssertInput();
  161.             return _Navigator.MoveToNextAttribute();
  162.         }
  163.         internal bool MoveToFirstNamespace()
  164.         {
  165.             AssertInput();
  166.             return _Navigator.MoveToFirstNamespace(XPathNamespaceScope.ExcludeXml);
  167.         }
  168.        
  169.         internal bool MoveToNextNamespace()
  170.         {
  171.             AssertInput();
  172.             return _Navigator.MoveToNextNamespace(XPathNamespaceScope.ExcludeXml);
  173.         }
  174.        
  175.         //
  176.         // Constructor
  177.         //
  178.         internal NavigatorInput(XPathNavigator navigator, string baseUri, InputScope rootScope)
  179.         {
  180.             if (navigator == null) {
  181.                 throw new ArgumentNullException("navigator");
  182.             }
  183.             if (baseUri == null) {
  184.                 throw new ArgumentNullException("baseUri");
  185.             }
  186.             Debug.Assert(navigator.NameTable != null);
  187.             _Next = null;
  188.             _Href = baseUri;
  189.             _Atoms = new Keywords(navigator.NameTable);
  190.             _Atoms.LookupKeywords();
  191.             _Navigator = navigator;
  192.             _Manager = new InputScopeManager(_Navigator, rootScope);
  193.             _PositionInfo = PositionInfo.GetPositionInfo(_Navigator);
  194.            
  195.             /*BeginReading:*/           
  196. AssertInput();
  197.             if (NodeType == XPathNodeType.Root) {
  198.                 _Navigator.MoveToFirstChild();
  199.             }
  200.         }
  201.        
  202.         internal NavigatorInput(XPathNavigator navigator) : this(navigator, navigator.BaseURI, null)
  203.         {
  204.         }
  205.        
  206.         //
  207.         // Debugging support
  208.         //
  209.         [System.Diagnostics.Conditional("DEBUG")]
  210.         internal void AssertInput()
  211.         {
  212.             Debug.Assert(_Navigator != null);
  213.         }
  214.     }
  215. }

Developer Fusion