The Labs \ Source Viewer \ SSCLI \ System.Xml.Serialization \ XmlCountingReader

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlCountingReader.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. // <owner current="true" primary="true">ElenaK</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Serialization
  17. {
  18.     using System.IO;
  19.     using System.Collections;
  20.     using System.Text;
  21.     using System;
  22.     using System.Xml.Schema;
  23.    
  24.     internal class XmlCountingReader : XmlReader, IXmlTextParser, IXmlLineInfo
  25.     {
  26.         XmlReader innerReader;
  27.         int advanceCount;
  28.        
  29.         internal XmlCountingReader(XmlReader xmlReader)
  30.         {
  31.             if (xmlReader == null)
  32.                 throw new ArgumentNullException("xmlReader");
  33.             this.innerReader = xmlReader;
  34.             this.advanceCount = 0;
  35.         }
  36.        
  37.         internal int AdvanceCount {
  38.             get { return advanceCount; }
  39.         }
  40.        
  41.         void IncrementCount()
  42.         {
  43.             if (advanceCount == Int32.MaxValue)
  44.                 advanceCount = 0;
  45.             else
  46.                 advanceCount++;
  47.         }
  48.        
  49.         // Properties (non-advancing)
  50.         public override XmlReaderSettings Settings {
  51.             get { return innerReader.Settings; }
  52.         }
  53.         public override XmlNodeType NodeType {
  54.             get { return innerReader.NodeType; }
  55.         }
  56.         public override string Name {
  57.             get { return innerReader.Name; }
  58.         }
  59.         public override string LocalName {
  60.             get { return innerReader.LocalName; }
  61.         }
  62.         public override string NamespaceURI {
  63.             get { return innerReader.NamespaceURI; }
  64.         }
  65.         public override string Prefix {
  66.             get { return innerReader.Prefix; }
  67.         }
  68.         public override bool HasValue {
  69.             get { return innerReader.HasValue; }
  70.         }
  71.         public override string Value {
  72.             get { return innerReader.Value; }
  73.         }
  74.         public override int Depth {
  75.             get { return innerReader.Depth; }
  76.         }
  77.         public override string BaseURI {
  78.             get { return innerReader.BaseURI; }
  79.         }
  80.         public override bool IsEmptyElement {
  81.             get { return innerReader.IsEmptyElement; }
  82.         }
  83.         public override bool IsDefault {
  84.             get { return innerReader.IsDefault; }
  85.         }
  86.         public override char QuoteChar {
  87.             get { return innerReader.QuoteChar; }
  88.         }
  89.         public override XmlSpace XmlSpace {
  90.             get { return innerReader.XmlSpace; }
  91.         }
  92.         public override string XmlLang {
  93.             get { return innerReader.XmlLang; }
  94.         }
  95.         public override IXmlSchemaInfo SchemaInfo {
  96.             get { return innerReader.SchemaInfo; }
  97.         }
  98.         public override Type ValueType {
  99.             get { return innerReader.ValueType; }
  100.         }
  101.         public override int AttributeCount {
  102.             get { return innerReader.AttributeCount; }
  103.         }
  104.         public override string this[int i]
  105.         {
  106.             get { return innerReader[i]; }
  107.         }
  108.         public override string this[string name]
  109.         {
  110.             get { return innerReader[name]; }
  111.         }
  112.         public override string this[string name, string namespaceURI]
  113.         {
  114.             get { return innerReader[name, namespaceURI]; }
  115.         }
  116.         public override bool EOF {
  117.             get { return innerReader.EOF; }
  118.         }
  119.         public override ReadState ReadState {
  120.             get { return innerReader.ReadState; }
  121.         }
  122.         public override XmlNameTable NameTable {
  123.             get { return innerReader.NameTable; }
  124.         }
  125.         public override bool CanResolveEntity {
  126.             get { return innerReader.CanResolveEntity; }
  127.         }
  128.         public override bool CanReadBinaryContent {
  129.             get { return innerReader.CanReadBinaryContent; }
  130.         }
  131.         public override bool CanReadValueChunk {
  132.             get { return innerReader.CanReadValueChunk; }
  133.         }
  134.         public override bool HasAttributes {
  135.             get { return innerReader.HasAttributes; }
  136.         }
  137.        
  138.         // Methods (non-advancing)
  139.         // Reader tends to under-count rather than over-count
  140.         public override void Close()
  141.         {
  142.             innerReader.Close();
  143.         }
  144.         public override string GetAttribute(string name)
  145.         {
  146.             return innerReader.GetAttribute(name);
  147.         }
  148.         public override string GetAttribute(string name, string namespaceURI)
  149.         {
  150.             return innerReader.GetAttribute(name, namespaceURI);
  151.         }
  152.         public override string GetAttribute(int i)
  153.         {
  154.             return innerReader.GetAttribute(i);
  155.         }
  156.         public override bool MoveToAttribute(string name)
  157.         {
  158.             return innerReader.MoveToAttribute(name);
  159.         }
  160.         public override bool MoveToAttribute(string name, string ns)
  161.         {
  162.             return innerReader.MoveToAttribute(name, ns);
  163.         }
  164.         public override void MoveToAttribute(int i)
  165.         {
  166.             innerReader.MoveToAttribute(i);
  167.         }
  168.         public override bool MoveToFirstAttribute()
  169.         {
  170.             return innerReader.MoveToFirstAttribute();
  171.         }
  172.         public override bool MoveToNextAttribute()
  173.         {
  174.             return innerReader.MoveToNextAttribute();
  175.         }
  176.         public override bool MoveToElement()
  177.         {
  178.             return innerReader.MoveToElement();
  179.         }
  180.         public override string LookupNamespace(string prefix)
  181.         {
  182.             return innerReader.LookupNamespace(prefix);
  183.         }
  184.         public override bool ReadAttributeValue()
  185.         {
  186.             return innerReader.ReadAttributeValue();
  187.         }
  188.         public override void ResolveEntity()
  189.         {
  190.             innerReader.ResolveEntity();
  191.         }
  192.         public override bool IsStartElement()
  193.         {
  194.             return innerReader.IsStartElement();
  195.         }
  196.         public override bool IsStartElement(string name)
  197.         {
  198.             return innerReader.IsStartElement(name);
  199.         }
  200.         public override bool IsStartElement(string localname, string ns)
  201.         {
  202.             return innerReader.IsStartElement(localname, ns);
  203.         }
  204.         public override XmlReader ReadSubtree()
  205.         {
  206.             return innerReader.ReadSubtree();
  207.         }
  208.         public override XmlNodeType MoveToContent()
  209.         {
  210.             return innerReader.MoveToContent();
  211.         }
  212.        
  213.         // Methods (advancing)
  214.         public override bool Read()
  215.         {
  216.             IncrementCount();
  217.             return innerReader.Read();
  218.         }
  219.        
  220.         public override void Skip()
  221.         {
  222.             IncrementCount();
  223.             innerReader.Skip();
  224.         }
  225.        
  226.         public override string ReadInnerXml()
  227.         {
  228.             if (innerReader.NodeType != XmlNodeType.Attribute)
  229.                 IncrementCount();
  230.             return innerReader.ReadInnerXml();
  231.         }
  232.         public override string ReadOuterXml()
  233.         {
  234.             if (innerReader.NodeType != XmlNodeType.Attribute)
  235.                 IncrementCount();
  236.             return innerReader.ReadOuterXml();
  237.         }
  238.         public override object ReadContentAsObject()
  239.         {
  240.             IncrementCount();
  241.             return innerReader.ReadContentAsObject();
  242.         }
  243.         public override bool ReadContentAsBoolean()
  244.         {
  245.             IncrementCount();
  246.             return innerReader.ReadContentAsBoolean();
  247.         }
  248.         public override DateTime ReadContentAsDateTime()
  249.         {
  250.             IncrementCount();
  251.             return innerReader.ReadContentAsDateTime();
  252.         }
  253.         public override double ReadContentAsDouble()
  254.         {
  255.             IncrementCount();
  256.             return innerReader.ReadContentAsDouble();
  257.         }
  258.         public override int ReadContentAsInt()
  259.         {
  260.             IncrementCount();
  261.             return innerReader.ReadContentAsInt();
  262.         }
  263.         public override long ReadContentAsLong()
  264.         {
  265.             IncrementCount();
  266.             return innerReader.ReadContentAsLong();
  267.         }
  268.         public override string ReadContentAsString()
  269.         {
  270.             IncrementCount();
  271.             return innerReader.ReadContentAsString();
  272.         }
  273.         public override object ReadContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver)
  274.         {
  275.             IncrementCount();
  276.             return innerReader.ReadContentAs(returnType, namespaceResolver);
  277.         }
  278.         public override object ReadElementContentAsObject()
  279.         {
  280.             IncrementCount();
  281.             return innerReader.ReadElementContentAsObject();
  282.         }
  283.         public override object ReadElementContentAsObject(string localName, string namespaceURI)
  284.         {
  285.             IncrementCount();
  286.             return innerReader.ReadElementContentAsObject(localName, namespaceURI);
  287.         }
  288.         public override bool ReadElementContentAsBoolean()
  289.         {
  290.             IncrementCount();
  291.             return innerReader.ReadElementContentAsBoolean();
  292.         }
  293.         public override bool ReadElementContentAsBoolean(string localName, string namespaceURI)
  294.         {
  295.             IncrementCount();
  296.             return innerReader.ReadElementContentAsBoolean(localName, namespaceURI);
  297.         }
  298.         public override DateTime ReadElementContentAsDateTime()
  299.         {
  300.             IncrementCount();
  301.             return innerReader.ReadElementContentAsDateTime();
  302.         }
  303.         public override DateTime ReadElementContentAsDateTime(string localName, string namespaceURI)
  304.         {
  305.             IncrementCount();
  306.             return innerReader.ReadElementContentAsDateTime(localName, namespaceURI);
  307.         }
  308.         public override double ReadElementContentAsDouble()
  309.         {
  310.             IncrementCount();
  311.             return innerReader.ReadElementContentAsDouble();
  312.         }
  313.         public override double ReadElementContentAsDouble(string localName, string namespaceURI)
  314.         {
  315.             IncrementCount();
  316.             return innerReader.ReadElementContentAsDouble(localName, namespaceURI);
  317.         }
  318.         public override int ReadElementContentAsInt()
  319.         {
  320.             IncrementCount();
  321.             return innerReader.ReadElementContentAsInt();
  322.         }
  323.         public override int ReadElementContentAsInt(string localName, string namespaceURI)
  324.         {
  325.             IncrementCount();
  326.             return innerReader.ReadElementContentAsInt(localName, namespaceURI);
  327.         }
  328.         public override long ReadElementContentAsLong()
  329.         {
  330.             IncrementCount();
  331.             return innerReader.ReadElementContentAsLong();
  332.         }
  333.         public override long ReadElementContentAsLong(string localName, string namespaceURI)
  334.         {
  335.             IncrementCount();
  336.             return innerReader.ReadElementContentAsLong(localName, namespaceURI);
  337.         }
  338.         public override string ReadElementContentAsString()
  339.         {
  340.             IncrementCount();
  341.             return innerReader.ReadElementContentAsString();
  342.         }
  343.         public override string ReadElementContentAsString(string localName, string namespaceURI)
  344.         {
  345.             IncrementCount();
  346.             return innerReader.ReadElementContentAsString(localName, namespaceURI);
  347.         }
  348.         public override object ReadElementContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver)
  349.         {
  350.             IncrementCount();
  351.             return innerReader.ReadElementContentAs(returnType, namespaceResolver);
  352.         }
  353.         public override object ReadElementContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver, string localName, string namespaceURI)
  354.         {
  355.             IncrementCount();
  356.             return innerReader.ReadElementContentAs(returnType, namespaceResolver, localName, namespaceURI);
  357.         }
  358.         public override int ReadContentAsBase64(byte[] buffer, int index, int count)
  359.         {
  360.             IncrementCount();
  361.             return innerReader.ReadContentAsBase64(buffer, index, count);
  362.         }
  363.         public override int ReadElementContentAsBase64(byte[] buffer, int index, int count)
  364.         {
  365.             IncrementCount();
  366.             return innerReader.ReadElementContentAsBase64(buffer, index, count);
  367.         }
  368.         public override int ReadContentAsBinHex(byte[] buffer, int index, int count)
  369.         {
  370.             IncrementCount();
  371.             return innerReader.ReadContentAsBinHex(buffer, index, count);
  372.         }
  373.         public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count)
  374.         {
  375.             IncrementCount();
  376.             return innerReader.ReadElementContentAsBinHex(buffer, index, count);
  377.         }
  378.         public override int ReadValueChunk(char[] buffer, int index, int count)
  379.         {
  380.             IncrementCount();
  381.             return innerReader.ReadValueChunk(buffer, index, count);
  382.         }
  383.         public override string ReadString()
  384.         {
  385.             IncrementCount();
  386.             return innerReader.ReadString();
  387.         }
  388.         public override void ReadStartElement()
  389.         {
  390.             IncrementCount();
  391.             innerReader.ReadStartElement();
  392.         }
  393.         public override void ReadStartElement(string name)
  394.         {
  395.             IncrementCount();
  396.             innerReader.ReadStartElement(name);
  397.         }
  398.         public override void ReadStartElement(string localname, string ns)
  399.         {
  400.             IncrementCount();
  401.             innerReader.ReadStartElement(localname, ns);
  402.         }
  403.         public override string ReadElementString()
  404.         {
  405.             IncrementCount();
  406.             return innerReader.ReadElementString();
  407.         }
  408.         public override string ReadElementString(string name)
  409.         {
  410.             IncrementCount();
  411.             return innerReader.ReadElementString(name);
  412.         }
  413.         public override string ReadElementString(string localname, string ns)
  414.         {
  415.             IncrementCount();
  416.             return innerReader.ReadElementString(localname, ns);
  417.         }
  418.         public override void ReadEndElement()
  419.         {
  420.             IncrementCount();
  421.             innerReader.ReadEndElement();
  422.         }
  423.         public override bool ReadToFollowing(string name)
  424.         {
  425.             IncrementCount();
  426.             return ReadToFollowing(name);
  427.         }
  428.         public override bool ReadToFollowing(string localName, string namespaceURI)
  429.         {
  430.             IncrementCount();
  431.             return innerReader.ReadToFollowing(localName, namespaceURI);
  432.         }
  433.         public override bool ReadToDescendant(string name)
  434.         {
  435.             IncrementCount();
  436.             return innerReader.ReadToDescendant(name);
  437.         }
  438.         public override bool ReadToDescendant(string localName, string namespaceURI)
  439.         {
  440.             IncrementCount();
  441.             return innerReader.ReadToDescendant(localName, namespaceURI);
  442.         }
  443.         public override bool ReadToNextSibling(string name)
  444.         {
  445.             IncrementCount();
  446.             return innerReader.ReadToNextSibling(name);
  447.         }
  448.         public override bool ReadToNextSibling(string localName, string namespaceURI)
  449.         {
  450.             IncrementCount();
  451.             return innerReader.ReadToNextSibling(localName, namespaceURI);
  452.         }
  453.        
  454.         // IDisposable interface
  455.         protected override void Dispose(bool disposing)
  456.         {
  457.             try {
  458.                 IDisposable disposableReader = innerReader as IDisposable;
  459.                 if (disposableReader != null)
  460.                     disposableReader.Dispose();
  461.             }
  462.             finally {
  463.                 base.Dispose(disposing);
  464.             }
  465.         }
  466.        
  467.         // IXmlTextParser members
  468.         bool IXmlTextParser.Normalized {
  469.             get {
  470.                 XmlTextReader xmlTextReader = innerReader as XmlTextReader;
  471.                 if (xmlTextReader == null) {
  472.                     IXmlTextParser xmlTextParser = innerReader as IXmlTextParser;
  473.                     return (xmlTextParser == null) ? false : xmlTextParser.Normalized;
  474.                 }
  475.                 else
  476.                     return xmlTextReader.Normalization;
  477.             }
  478.             set {
  479.                 XmlTextReader xmlTextReader = innerReader as XmlTextReader;
  480.                 if (xmlTextReader == null) {
  481.                     IXmlTextParser xmlTextParser = innerReader as IXmlTextParser;
  482.                     if (xmlTextParser != null)
  483.                         xmlTextParser.Normalized = value;
  484.                 }
  485.                 else
  486.                     xmlTextReader.Normalization = value;
  487.             }
  488.         }
  489.        
  490.         WhitespaceHandling IXmlTextParser.WhitespaceHandling {
  491.             get {
  492.                 XmlTextReader xmlTextReader = innerReader as XmlTextReader;
  493.                 if (xmlTextReader == null) {
  494.                     IXmlTextParser xmlTextParser = innerReader as IXmlTextParser;
  495.                     return (xmlTextParser == null) ? WhitespaceHandling.None : xmlTextParser.WhitespaceHandling;
  496.                 }
  497.                 else
  498.                     return xmlTextReader.WhitespaceHandling;
  499.             }
  500.             set {
  501.                 XmlTextReader xmlTextReader = innerReader as XmlTextReader;
  502.                 if (xmlTextReader == null) {
  503.                     IXmlTextParser xmlTextParser = innerReader as IXmlTextParser;
  504.                     if (xmlTextParser != null)
  505.                         xmlTextParser.WhitespaceHandling = value;
  506.                 }
  507.                 else
  508.                     xmlTextReader.WhitespaceHandling = value;
  509.             }
  510.         }
  511.        
  512.         // IXmlLineInfo members
  513.         bool IXmlLineInfo.HasLineInfo()
  514.         {
  515.             IXmlLineInfo iXmlLineInfo = innerReader as IXmlLineInfo;
  516.             return (iXmlLineInfo == null) ? false : iXmlLineInfo.HasLineInfo();
  517.         }
  518.        
  519.         int IXmlLineInfo.LineNumber {
  520.             get {
  521.                 IXmlLineInfo iXmlLineInfo = innerReader as IXmlLineInfo;
  522.                 return (iXmlLineInfo == null) ? 0 : iXmlLineInfo.LineNumber;
  523.             }
  524.         }
  525.        
  526.         int IXmlLineInfo.LinePosition {
  527.             get {
  528.                 IXmlLineInfo iXmlLineInfo = innerReader as IXmlLineInfo;
  529.                 return (iXmlLineInfo == null) ? 0 : iXmlLineInfo.LinePosition;
  530.             }
  531.         }
  532.        
  533.     }
  534. }

Developer Fusion