The Labs \ Source Viewer \ SSCLI \ System.Xml \ XmlTextReader

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlTextReader.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. using System;
  16. using System.IO;
  17. using System.Text;
  18. using System.Xml.Schema;
  19. using System.Collections;
  20. using System.Security.Policy;
  21. using System.Collections.Generic;
  22. using System.Security.Permissions;
  23. namespace System.Xml
  24. {
  25.    
  26.     [PermissionSetAttribute(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  27.     public partial class XmlTextReader : XmlReader, IXmlLineInfo, IXmlNamespaceResolver
  28.     {
  29.         //
  30.         // Member fields
  31.         //
  32.         XmlTextReaderImpl impl;
  33.         //
  34.         //
  35.         // Constructors
  36.         //
  37.         protected XmlTextReader()
  38.         {
  39.             impl = new XmlTextReaderImpl();
  40.             impl.OuterReader = this;
  41.         }
  42.        
  43.         protected XmlTextReader(XmlNameTable nt)
  44.         {
  45.             impl = new XmlTextReaderImpl(nt);
  46.             impl.OuterReader = this;
  47.         }
  48.        
  49.         public XmlTextReader(Stream input)
  50.         {
  51.             impl = new XmlTextReaderImpl(input);
  52.             impl.OuterReader = this;
  53.         }
  54.        
  55.         public XmlTextReader(string url, Stream input)
  56.         {
  57.             impl = new XmlTextReaderImpl(url, input);
  58.             impl.OuterReader = this;
  59.         }
  60.        
  61.         public XmlTextReader(Stream input, XmlNameTable nt)
  62.         {
  63.             impl = new XmlTextReaderImpl(input, nt);
  64.             impl.OuterReader = this;
  65.         }
  66.        
  67.         public XmlTextReader(string url, Stream input, XmlNameTable nt)
  68.         {
  69.             impl = new XmlTextReaderImpl(url, input, nt);
  70.             impl.OuterReader = this;
  71.         }
  72.        
  73.         public XmlTextReader(TextReader input)
  74.         {
  75.             impl = new XmlTextReaderImpl(input);
  76.             impl.OuterReader = this;
  77.         }
  78.        
  79.         public XmlTextReader(string url, TextReader input)
  80.         {
  81.             impl = new XmlTextReaderImpl(url, input);
  82.             impl.OuterReader = this;
  83.         }
  84.        
  85.         public XmlTextReader(TextReader input, XmlNameTable nt)
  86.         {
  87.             impl = new XmlTextReaderImpl(input, nt);
  88.             impl.OuterReader = this;
  89.         }
  90.        
  91.         public XmlTextReader(string url, TextReader input, XmlNameTable nt)
  92.         {
  93.             impl = new XmlTextReaderImpl(url, input, nt);
  94.             impl.OuterReader = this;
  95.         }
  96.        
  97.         public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context)
  98.         {
  99.             impl = new XmlTextReaderImpl(xmlFragment, fragType, context);
  100.             impl.OuterReader = this;
  101.         }
  102.        
  103.         public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context)
  104.         {
  105.             impl = new XmlTextReaderImpl(xmlFragment, fragType, context);
  106.             impl.OuterReader = this;
  107.         }
  108.        
  109.         public XmlTextReader(string url)
  110.         {
  111.             impl = new XmlTextReaderImpl(url, new NameTable());
  112.             impl.OuterReader = this;
  113.         }
  114.        
  115.         public XmlTextReader(string url, XmlNameTable nt)
  116.         {
  117.             impl = new XmlTextReaderImpl(url, nt);
  118.             impl.OuterReader = this;
  119.         }
  120.         //
  121.         // XmlReader members
  122.         //
  123.         public override XmlReaderSettings Settings {
  124.             get { return null; }
  125.         }
  126.        
  127.         public override XmlNodeType NodeType {
  128.             get { return impl.NodeType; }
  129.         }
  130.        
  131.         public override string Name {
  132.             get { return impl.Name; }
  133.         }
  134.        
  135.         public override string LocalName {
  136.             get { return impl.LocalName; }
  137.         }
  138.        
  139.         public override string NamespaceURI {
  140.             get { return impl.NamespaceURI; }
  141.         }
  142.        
  143.         public override string Prefix {
  144.             get { return impl.Prefix; }
  145.         }
  146.        
  147.         public override bool HasValue {
  148.             get { return impl.HasValue; }
  149.         }
  150.        
  151.         public override string Value {
  152.             get { return impl.Value; }
  153.         }
  154.        
  155.         public override int Depth {
  156.             get { return impl.Depth; }
  157.         }
  158.        
  159.         public override string BaseURI {
  160.             get { return impl.BaseURI; }
  161.         }
  162.        
  163.         public override bool IsEmptyElement {
  164.             get { return impl.IsEmptyElement; }
  165.         }
  166.        
  167.         public override bool IsDefault {
  168.             get { return impl.IsDefault; }
  169.         }
  170.        
  171.         public override char QuoteChar {
  172.             get { return impl.QuoteChar; }
  173.         }
  174.        
  175.         public override XmlSpace XmlSpace {
  176.             get { return impl.XmlSpace; }
  177.         }
  178.        
  179.         public override string XmlLang {
  180.             get { return impl.XmlLang; }
  181.         }
  182.        
  183.         // XmlTextReader does not override SchemaInfo, ValueType and ReadTypeValue
  184.        
  185.         public override int AttributeCount {
  186.             get { return impl.AttributeCount; }
  187.         }
  188.        
  189.         public override string GetAttribute(string name)
  190.         {
  191.             return impl.GetAttribute(name);
  192.         }
  193.        
  194.         public override string GetAttribute(string localName, string namespaceURI)
  195.         {
  196.             return impl.GetAttribute(localName, namespaceURI);
  197.         }
  198.        
  199.         public override string GetAttribute(int i)
  200.         {
  201.             return impl.GetAttribute(i);
  202.         }
  203.        
  204.         public override bool MoveToAttribute(string name)
  205.         {
  206.             return impl.MoveToAttribute(name);
  207.         }
  208.        
  209.         public override bool MoveToAttribute(string localName, string namespaceURI)
  210.         {
  211.             return impl.MoveToAttribute(localName, namespaceURI);
  212.         }
  213.        
  214.         public override void MoveToAttribute(int i)
  215.         {
  216.             impl.MoveToAttribute(i);
  217.         }
  218.        
  219.         public override bool MoveToFirstAttribute()
  220.         {
  221.             return impl.MoveToFirstAttribute();
  222.         }
  223.        
  224.         public override bool MoveToNextAttribute()
  225.         {
  226.             return impl.MoveToNextAttribute();
  227.         }
  228.        
  229.         public override bool MoveToElement()
  230.         {
  231.             return impl.MoveToElement();
  232.         }
  233.        
  234.         public override bool ReadAttributeValue()
  235.         {
  236.             return impl.ReadAttributeValue();
  237.         }
  238.        
  239.         public override bool Read()
  240.         {
  241.             return impl.Read();
  242.         }
  243.        
  244.         public override bool EOF {
  245.             get { return impl.EOF; }
  246.         }
  247.        
  248.         public override void Close()
  249.         {
  250.             impl.Close();
  251.         }
  252.        
  253.         public override ReadState ReadState {
  254.             get { return impl.ReadState; }
  255.         }
  256.        
  257.         public override void Skip()
  258.         {
  259.             impl.Skip();
  260.         }
  261.        
  262.         public override XmlNameTable NameTable {
  263.             get { return impl.NameTable; }
  264.         }
  265.        
  266.         public override string LookupNamespace(string prefix)
  267.         {
  268.             string ns = impl.LookupNamespace(prefix);
  269.             if (ns != null && ns.Length == 0) {
  270.                 ns = null;
  271.             }
  272.             return ns;
  273.         }
  274.        
  275.         public override bool CanResolveEntity {
  276.             get { return true; }
  277.         }
  278.        
  279.         public override void ResolveEntity()
  280.         {
  281.             impl.ResolveEntity();
  282.         }
  283.        
  284.         // Binary content access methods
  285.         public override bool CanReadBinaryContent {
  286.             get { return true; }
  287.         }
  288.        
  289.         public override int ReadContentAsBase64(byte[] buffer, int index, int count)
  290.         {
  291.             return impl.ReadContentAsBase64(buffer, index, count);
  292.         }
  293.        
  294.         public override int ReadElementContentAsBase64(byte[] buffer, int index, int count)
  295.         {
  296.             return impl.ReadElementContentAsBase64(buffer, index, count);
  297.         }
  298.        
  299.         public override int ReadContentAsBinHex(byte[] buffer, int index, int count)
  300.         {
  301.             return impl.ReadContentAsBinHex(buffer, index, count);
  302.         }
  303.        
  304.         public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count)
  305.         {
  306.             return impl.ReadElementContentAsBinHex(buffer, index, count);
  307.         }
  308.        
  309.         // Text streaming methods
  310.        
  311.         // XmlTextReader does do support streaming of Value (there are backwards compatibility issues when enabled)
  312.         public override bool CanReadValueChunk {
  313.             get { return false; }
  314.         }
  315.        
  316.         // Overriden helper methods
  317.        
  318.         public override string ReadString()
  319.         {
  320.             impl.MoveOffEntityReference();
  321.             return base.ReadString();
  322.         }
  323.        
  324.         //
  325.         // IXmlLineInfo members
  326.         //
  327.         public bool HasLineInfo()
  328.         {
  329.             return true;
  330.         }
  331.        
  332.         public int LineNumber {
  333.             get { return impl.LineNumber; }
  334.         }
  335.        
  336.         public int LinePosition {
  337.             get { return impl.LinePosition; }
  338.         }
  339.        
  340.         //
  341.         // IXmlNamespaceResolver members
  342.         //
  343.         IDictionary<string, string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope)
  344.         {
  345.             return impl.GetNamespacesInScope(scope);
  346.         }
  347.        
  348.         string IXmlNamespaceResolver.LookupNamespace(string prefix)
  349.         {
  350.             return impl.LookupNamespace(prefix);
  351.         }
  352.        
  353.         string IXmlNamespaceResolver.LookupPrefix(string namespaceName)
  354.         {
  355.             return impl.LookupPrefix(namespaceName);
  356.         }
  357.        
  358.         #pragma warning disable 3002
  359.         // FXCOP: ExplicitMethodImplementationsInUnsealedClassesHaveVisibleAlternates
  360.         // public versions of IXmlNamespaceResolver methods, so that XmlTextReader subclasses can access them
  361.         public IDictionary<string, string> GetNamespacesInScope(XmlNamespaceScope scope)
  362.         {
  363.             return impl.GetNamespacesInScope(scope);
  364.         }
  365.         #pragma warning restore 3002
  366.        
  367.         //
  368.         // XmlTextReader
  369.         //
  370.         public bool Namespaces {
  371.             get { return impl.Namespaces; }
  372.             set { impl.Namespaces = value; }
  373.         }
  374.        
  375.         public bool Normalization {
  376.             get { return impl.Normalization; }
  377.             set { impl.Normalization = value; }
  378.         }
  379.        
  380.         public Encoding Encoding {
  381.             get { return impl.Encoding; }
  382.         }
  383.        
  384.         public WhitespaceHandling WhitespaceHandling {
  385.             get { return impl.WhitespaceHandling; }
  386.             set { impl.WhitespaceHandling = value; }
  387.         }
  388.        
  389.         public bool ProhibitDtd {
  390.             get { return impl.ProhibitDtd; }
  391.             set { impl.ProhibitDtd = value; }
  392.         }
  393.        
  394.         public EntityHandling EntityHandling {
  395.             get { return impl.EntityHandling; }
  396.             set { impl.EntityHandling = value; }
  397.         }
  398.        
  399.         public XmlResolver XmlResolver {
  400.             set { impl.XmlResolver = value; }
  401.         }
  402.        
  403.         public void ResetState()
  404.         {
  405.             impl.ResetState();
  406.         }
  407.        
  408.         public TextReader GetRemainder()
  409.         {
  410.             return impl.GetRemainder();
  411.         }
  412.        
  413.         public int ReadChars(char[] buffer, int index, int count)
  414.         {
  415.             return impl.ReadChars(buffer, index, count);
  416.         }
  417.        
  418.         public int ReadBase64(byte[] array, int offset, int len)
  419.         {
  420.             return impl.ReadBase64(array, offset, len);
  421.         }
  422.        
  423.         public int ReadBinHex(byte[] array, int offset, int len)
  424.         {
  425.             return impl.ReadBinHex(array, offset, len);
  426.         }
  427.         //
  428.         // Internal helper methods
  429.         //
  430.         internal XmlTextReaderImpl Impl {
  431.             get { return impl; }
  432.         }
  433.        
  434.         internal override XmlNamespaceManager NamespaceManager {
  435.             get { return impl.NamespaceManager; }
  436.         }
  437.        
  438.         // NOTE: System.Data.SqlXml.XmlDataSourceResolver accesses this property via reflection
  439.         internal bool XmlValidatingReaderCompatibilityMode {
  440.             set { impl.XmlValidatingReaderCompatibilityMode = value; }
  441.         }
  442.     }
  443. }

Developer Fusion