You've already forked linux-packaging-mono
1773 lines
62 KiB
C#
1773 lines
62 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.Xml
|
|
{
|
|
using System;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Xml;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using System.Runtime.Serialization;
|
|
using System.Globalization;
|
|
|
|
public delegate void OnXmlDictionaryReaderClose(XmlDictionaryReader reader);
|
|
|
|
public abstract class XmlDictionaryReader : XmlReader
|
|
{
|
|
internal const int MaxInitialArrayLength = 65535;
|
|
|
|
static public XmlDictionaryReader CreateDictionaryReader(XmlReader reader)
|
|
{
|
|
if (reader == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
|
|
|
|
XmlDictionaryReader dictionaryReader = reader as XmlDictionaryReader;
|
|
|
|
if (dictionaryReader == null)
|
|
{
|
|
dictionaryReader = new XmlWrappedReader(reader, null);
|
|
}
|
|
|
|
return dictionaryReader;
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
if (buffer == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("buffer");
|
|
return CreateBinaryReader(buffer, 0, buffer.Length, quotas);
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, int offset, int count, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateBinaryReader(buffer, offset, count, null, quotas);
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, int offset, int count, IXmlDictionary dictionary, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateBinaryReader(buffer, offset, count, dictionary, quotas, null);
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, int offset, int count, IXmlDictionary dictionary, XmlDictionaryReaderQuotas quotas, XmlBinaryReaderSession session)
|
|
{
|
|
return CreateBinaryReader(buffer, offset, count, dictionary, quotas, session, null);
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(byte[] buffer, int offset, int count,
|
|
IXmlDictionary dictionary,
|
|
XmlDictionaryReaderQuotas quotas,
|
|
XmlBinaryReaderSession session,
|
|
OnXmlDictionaryReaderClose onClose)
|
|
{
|
|
XmlBinaryReader reader = new XmlBinaryReader();
|
|
reader.SetInput(buffer, offset, count, dictionary, quotas, session, onClose);
|
|
return reader;
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(Stream stream, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateBinaryReader(stream, null, quotas);
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(Stream stream, IXmlDictionary dictionary, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateBinaryReader(stream, dictionary, quotas, null);
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(Stream stream, IXmlDictionary dictionary, XmlDictionaryReaderQuotas quotas, XmlBinaryReaderSession session)
|
|
{
|
|
return CreateBinaryReader(stream, dictionary, quotas, session, null);
|
|
}
|
|
|
|
public static XmlDictionaryReader CreateBinaryReader(Stream stream,
|
|
IXmlDictionary dictionary,
|
|
XmlDictionaryReaderQuotas quotas,
|
|
XmlBinaryReaderSession session,
|
|
OnXmlDictionaryReaderClose onClose)
|
|
{
|
|
XmlBinaryReader reader = new XmlBinaryReader();
|
|
reader.SetInput(stream, dictionary, quotas, session, onClose);
|
|
return reader;
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateTextReader(byte[] buffer, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
if (buffer == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("buffer");
|
|
return CreateTextReader(buffer, 0, buffer.Length, quotas);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateTextReader(byte[] buffer, int offset, int count, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateTextReader(buffer, offset, count, null, quotas, null);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateTextReader(byte[] buffer, int offset, int count,
|
|
Encoding encoding,
|
|
XmlDictionaryReaderQuotas quotas,
|
|
OnXmlDictionaryReaderClose onClose)
|
|
{
|
|
XmlUTF8TextReader reader = new XmlUTF8TextReader();
|
|
reader.SetInput(buffer, offset, count, encoding, quotas, onClose);
|
|
return reader;
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateTextReader(Stream stream, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateTextReader(stream, null, quotas, null);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateTextReader(Stream stream, Encoding encoding,
|
|
XmlDictionaryReaderQuotas quotas,
|
|
OnXmlDictionaryReaderClose onClose)
|
|
{
|
|
XmlUTF8TextReader reader = new XmlUTF8TextReader();
|
|
reader.SetInput(stream, encoding, quotas, onClose);
|
|
return reader;
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateMtomReader(Stream stream, Encoding encoding, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
if (encoding == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("encoding");
|
|
|
|
return CreateMtomReader(stream, new Encoding[1] { encoding }, quotas);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateMtomReader(Stream stream, Encoding[] encodings, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateMtomReader(stream, encodings, null, quotas);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateMtomReader(Stream stream, Encoding[] encodings, string contentType, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateMtomReader(stream, encodings, contentType, quotas, int.MaxValue, null);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateMtomReader(Stream stream, Encoding[] encodings, string contentType,
|
|
XmlDictionaryReaderQuotas quotas, int maxBufferSize, OnXmlDictionaryReaderClose onClose)
|
|
{
|
|
XmlMtomReader reader = new XmlMtomReader();
|
|
reader.SetInput(stream, encodings, contentType, quotas, maxBufferSize, onClose);
|
|
return reader;
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateMtomReader(byte[] buffer, int offset, int count, Encoding encoding, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
if (encoding == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("encoding");
|
|
|
|
return CreateMtomReader(buffer, offset, count, new Encoding[1] { encoding }, quotas);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateMtomReader(byte[] buffer, int offset, int count, Encoding[] encodings, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateMtomReader(buffer, offset, count, encodings, null, quotas);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateMtomReader(byte[] buffer, int offset, int count, Encoding[] encodings, string contentType, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
return CreateMtomReader(buffer, offset, count, encodings, contentType, quotas, int.MaxValue, null);
|
|
}
|
|
|
|
static public XmlDictionaryReader CreateMtomReader(byte[] buffer, int offset, int count, Encoding[] encodings, string contentType,
|
|
XmlDictionaryReaderQuotas quotas, int maxBufferSize, OnXmlDictionaryReaderClose onClose)
|
|
{
|
|
XmlMtomReader reader = new XmlMtomReader();
|
|
reader.SetInput(buffer, offset, count, encodings, contentType, quotas, maxBufferSize, onClose);
|
|
return reader;
|
|
}
|
|
|
|
#if NO
|
|
static XmlDictionaryReader CreateMtomReader(byte[] buffer, int offset, int count, Encoding encoding)
|
|
{
|
|
return XmlMtomWriter.IsUTF8Encoding(encoding) ? new XmlUTF8TextReader(buffer, offset, count)
|
|
: CreateReader(new MemoryStream(buffer, offset, count), encoding);
|
|
}
|
|
#endif
|
|
public virtual bool CanCanonicalize
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public virtual XmlDictionaryReaderQuotas Quotas
|
|
{
|
|
get
|
|
{
|
|
return XmlDictionaryReaderQuotas.Max;
|
|
}
|
|
}
|
|
|
|
public virtual void StartCanonicalization(Stream stream, bool includeComments, string[] inclusivePrefixes)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
|
|
}
|
|
|
|
public virtual void EndCanonicalization()
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
|
|
}
|
|
|
|
public virtual void MoveToStartElement()
|
|
{
|
|
if (!IsStartElement())
|
|
XmlExceptionHelper.ThrowStartElementExpected(this);
|
|
}
|
|
|
|
public virtual void MoveToStartElement(string name)
|
|
{
|
|
if (!IsStartElement(name))
|
|
XmlExceptionHelper.ThrowStartElementExpected(this, name);
|
|
}
|
|
|
|
public virtual void MoveToStartElement(string localName, string namespaceUri)
|
|
{
|
|
if (!IsStartElement(localName, namespaceUri))
|
|
XmlExceptionHelper.ThrowStartElementExpected(this, localName, namespaceUri);
|
|
}
|
|
|
|
public virtual void MoveToStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
if (!IsStartElement(localName, namespaceUri))
|
|
XmlExceptionHelper.ThrowStartElementExpected(this, localName, namespaceUri);
|
|
}
|
|
|
|
public virtual bool IsLocalName(string localName)
|
|
{
|
|
return this.LocalName == localName;
|
|
}
|
|
|
|
public virtual bool IsLocalName(XmlDictionaryString localName)
|
|
{
|
|
if (localName == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("localName");
|
|
|
|
return IsLocalName(localName.Value);
|
|
}
|
|
|
|
public virtual bool IsNamespaceUri(string namespaceUri)
|
|
{
|
|
if (namespaceUri == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("namespaceUri");
|
|
return this.NamespaceURI == namespaceUri;
|
|
}
|
|
|
|
public virtual bool IsNamespaceUri(XmlDictionaryString namespaceUri)
|
|
{
|
|
if (namespaceUri == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("namespaceUri");
|
|
return IsNamespaceUri(namespaceUri.Value);
|
|
}
|
|
|
|
public virtual void ReadFullStartElement()
|
|
{
|
|
MoveToStartElement();
|
|
if (IsEmptyElement)
|
|
XmlExceptionHelper.ThrowFullStartElementExpected(this);
|
|
Read();
|
|
}
|
|
|
|
public virtual void ReadFullStartElement(string name)
|
|
{
|
|
MoveToStartElement(name);
|
|
if (IsEmptyElement)
|
|
XmlExceptionHelper.ThrowFullStartElementExpected(this, name);
|
|
Read();
|
|
}
|
|
|
|
public virtual void ReadFullStartElement(string localName, string namespaceUri)
|
|
{
|
|
MoveToStartElement(localName, namespaceUri);
|
|
if (IsEmptyElement)
|
|
XmlExceptionHelper.ThrowFullStartElementExpected(this, localName, namespaceUri);
|
|
Read();
|
|
}
|
|
|
|
public virtual void ReadFullStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
MoveToStartElement(localName, namespaceUri);
|
|
if (IsEmptyElement)
|
|
XmlExceptionHelper.ThrowFullStartElementExpected(this, localName, namespaceUri);
|
|
Read();
|
|
}
|
|
|
|
public virtual void ReadStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
MoveToStartElement(localName, namespaceUri);
|
|
Read();
|
|
}
|
|
|
|
public virtual bool IsStartElement(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return IsStartElement(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri));
|
|
}
|
|
|
|
public virtual int IndexOfLocalName(string[] localNames, string namespaceUri)
|
|
{
|
|
if (localNames == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("localNames");
|
|
|
|
if (namespaceUri == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("namespaceUri");
|
|
|
|
if (this.NamespaceURI == namespaceUri)
|
|
{
|
|
string localName = this.LocalName;
|
|
for (int i = 0; i < localNames.Length; i++)
|
|
{
|
|
string value = localNames[i];
|
|
if (value == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(string.Format(CultureInfo.InvariantCulture, "localNames[{0}]", i));
|
|
if (localName == value)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public virtual int IndexOfLocalName(XmlDictionaryString[] localNames, XmlDictionaryString namespaceUri)
|
|
{
|
|
if (localNames == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("localNames");
|
|
|
|
if (namespaceUri == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("namespaceUri");
|
|
|
|
if (this.NamespaceURI == namespaceUri.Value)
|
|
{
|
|
string localName = this.LocalName;
|
|
for (int i = 0; i < localNames.Length; i++)
|
|
{
|
|
XmlDictionaryString value = localNames[i];
|
|
if (value == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(string.Format(CultureInfo.InvariantCulture, "localNames[{0}]", i));
|
|
if (localName == value.Value)
|
|
{
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
public virtual string GetAttribute(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return GetAttribute(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri));
|
|
}
|
|
|
|
public virtual bool TryGetBase64ContentLength(out int length)
|
|
{
|
|
length = 0;
|
|
return false;
|
|
}
|
|
|
|
public virtual int ReadValueAsBase64(byte[] buffer, int offset, int count)
|
|
{
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
|
|
}
|
|
|
|
public virtual byte[] ReadContentAsBase64()
|
|
{
|
|
return ReadContentAsBase64(Quotas.MaxArrayLength, MaxInitialArrayLength);
|
|
}
|
|
|
|
internal byte[] ReadContentAsBase64(int maxByteArrayContentLength, int maxInitialCount)
|
|
{
|
|
int length;
|
|
if (TryGetBase64ContentLength(out length))
|
|
{
|
|
if (length > maxByteArrayContentLength)
|
|
XmlExceptionHelper.ThrowMaxArrayLengthExceeded(this, maxByteArrayContentLength);
|
|
|
|
if (length <= maxInitialCount)
|
|
{
|
|
byte[] buffer = new byte[length];
|
|
int read = 0;
|
|
while (read < length)
|
|
{
|
|
int actual = ReadContentAsBase64(buffer, read, length - read);
|
|
if (actual == 0)
|
|
XmlExceptionHelper.ThrowBase64DataExpected(this);
|
|
read += actual;
|
|
}
|
|
return buffer;
|
|
}
|
|
}
|
|
return ReadContentAsBytes(true, maxByteArrayContentLength);
|
|
}
|
|
|
|
public override string ReadContentAsString()
|
|
{
|
|
return ReadContentAsString(Quotas.MaxStringContentLength);
|
|
}
|
|
|
|
protected string ReadContentAsString(int maxStringContentLength)
|
|
{
|
|
StringBuilder sb = null;
|
|
string result = string.Empty;
|
|
bool done = false;
|
|
while (true)
|
|
{
|
|
switch (this.NodeType)
|
|
{
|
|
case XmlNodeType.Attribute:
|
|
result = this.Value;
|
|
break;
|
|
case XmlNodeType.Text:
|
|
case XmlNodeType.Whitespace:
|
|
case XmlNodeType.SignificantWhitespace:
|
|
case XmlNodeType.CDATA:
|
|
// merge text content
|
|
string value = this.Value;
|
|
if (result.Length == 0)
|
|
{
|
|
result = value;
|
|
}
|
|
else
|
|
{
|
|
if (sb == null)
|
|
sb = new StringBuilder(result);
|
|
if (sb.Length > maxStringContentLength - value.Length)
|
|
XmlExceptionHelper.ThrowMaxStringContentLengthExceeded(this, maxStringContentLength);
|
|
sb.Append(value);
|
|
}
|
|
break;
|
|
case XmlNodeType.ProcessingInstruction:
|
|
case XmlNodeType.Comment:
|
|
case XmlNodeType.EndEntity:
|
|
// skip comments, pis and end entity nodes
|
|
break;
|
|
case XmlNodeType.EntityReference:
|
|
if (this.CanResolveEntity)
|
|
{
|
|
this.ResolveEntity();
|
|
break;
|
|
}
|
|
goto default;
|
|
case XmlNodeType.Element:
|
|
case XmlNodeType.EndElement:
|
|
default:
|
|
done = true;
|
|
break;
|
|
}
|
|
if (done)
|
|
break;
|
|
if (this.AttributeCount != 0)
|
|
ReadAttributeValue();
|
|
else
|
|
Read();
|
|
}
|
|
if (sb != null)
|
|
result = sb.ToString();
|
|
if (result.Length > maxStringContentLength)
|
|
XmlExceptionHelper.ThrowMaxStringContentLengthExceeded(this, maxStringContentLength);
|
|
return result;
|
|
}
|
|
|
|
public override string ReadString()
|
|
{
|
|
return ReadString(Quotas.MaxStringContentLength);
|
|
}
|
|
|
|
protected string ReadString(int maxStringContentLength)
|
|
{
|
|
if (this.ReadState != ReadState.Interactive)
|
|
return string.Empty;
|
|
if (this.NodeType != XmlNodeType.Element)
|
|
MoveToElement();
|
|
if (this.NodeType == XmlNodeType.Element)
|
|
{
|
|
if (this.IsEmptyElement)
|
|
return string.Empty;
|
|
if (!Read())
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidOperation)));
|
|
if (this.NodeType == XmlNodeType.EndElement)
|
|
return string.Empty;
|
|
}
|
|
StringBuilder sb = null;
|
|
string result = string.Empty;
|
|
while (IsTextNode(this.NodeType))
|
|
{
|
|
string value = this.Value;
|
|
if (result.Length == 0)
|
|
{
|
|
result = value;
|
|
}
|
|
else
|
|
{
|
|
if (sb == null)
|
|
sb = new StringBuilder(result);
|
|
if (sb.Length > maxStringContentLength - value.Length)
|
|
XmlExceptionHelper.ThrowMaxStringContentLengthExceeded(this, maxStringContentLength);
|
|
sb.Append(value);
|
|
}
|
|
if (!Read())
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidOperation)));
|
|
}
|
|
if (sb != null)
|
|
result = sb.ToString();
|
|
if (result.Length > maxStringContentLength)
|
|
XmlExceptionHelper.ThrowMaxStringContentLengthExceeded(this, maxStringContentLength);
|
|
return result;
|
|
}
|
|
|
|
public virtual byte[] ReadContentAsBinHex()
|
|
{
|
|
return ReadContentAsBinHex(Quotas.MaxArrayLength);
|
|
}
|
|
|
|
protected byte[] ReadContentAsBinHex(int maxByteArrayContentLength)
|
|
{
|
|
return ReadContentAsBytes(false, maxByteArrayContentLength);
|
|
}
|
|
|
|
byte[] ReadContentAsBytes(bool base64, int maxByteArrayContentLength)
|
|
{
|
|
byte[][] buffers = new byte[32][];
|
|
byte[] buffer;
|
|
// Its best to read in buffers that are a multiple of 3 so we don't break base64 boundaries when converting text
|
|
int count = 384;
|
|
int bufferCount = 0;
|
|
int totalRead = 0;
|
|
while (true)
|
|
{
|
|
buffer = new byte[count];
|
|
buffers[bufferCount++] = buffer;
|
|
int read = 0;
|
|
while (read < buffer.Length)
|
|
{
|
|
int actual;
|
|
if (base64)
|
|
actual = ReadContentAsBase64(buffer, read, buffer.Length - read);
|
|
else
|
|
actual = ReadContentAsBinHex(buffer, read, buffer.Length - read);
|
|
if (actual == 0)
|
|
break;
|
|
read += actual;
|
|
}
|
|
if (totalRead > maxByteArrayContentLength - read)
|
|
XmlExceptionHelper.ThrowMaxArrayLengthExceeded(this, maxByteArrayContentLength);
|
|
totalRead += read;
|
|
if (read < buffer.Length)
|
|
break;
|
|
count = count * 2;
|
|
}
|
|
buffer = new byte[totalRead];
|
|
int offset = 0;
|
|
for (int i = 0; i < bufferCount - 1; i++)
|
|
{
|
|
Buffer.BlockCopy(buffers[i], 0, buffer, offset, buffers[i].Length);
|
|
offset += buffers[i].Length;
|
|
}
|
|
Buffer.BlockCopy(buffers[bufferCount - 1], 0, buffer, offset, totalRead - offset);
|
|
return buffer;
|
|
}
|
|
|
|
protected bool IsTextNode(XmlNodeType nodeType)
|
|
{
|
|
return nodeType == XmlNodeType.Text ||
|
|
nodeType == XmlNodeType.Whitespace ||
|
|
nodeType == XmlNodeType.SignificantWhitespace ||
|
|
nodeType == XmlNodeType.CDATA ||
|
|
nodeType == XmlNodeType.Attribute;
|
|
}
|
|
|
|
public virtual int ReadContentAsChars(char[] chars, int offset, int count)
|
|
{
|
|
int read = 0;
|
|
while (true)
|
|
{
|
|
XmlNodeType nodeType = this.NodeType;
|
|
|
|
if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement)
|
|
break;
|
|
|
|
if (IsTextNode(nodeType))
|
|
{
|
|
read = ReadValueChunk(chars, offset, count);
|
|
|
|
if (read > 0)
|
|
break;
|
|
|
|
if (nodeType == XmlNodeType.Attribute /* || inAttributeText */)
|
|
break;
|
|
|
|
if (!Read())
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (!Read())
|
|
break;
|
|
}
|
|
}
|
|
|
|
return read;
|
|
}
|
|
|
|
public override object ReadContentAs(Type type, IXmlNamespaceResolver namespaceResolver)
|
|
{
|
|
if (type == typeof(Guid[]))
|
|
{
|
|
string[] values = (string[])ReadContentAs(typeof(string[]), namespaceResolver);
|
|
Guid[] guids = new Guid[values.Length];
|
|
for (int i = 0; i < values.Length; i++)
|
|
guids[i] = XmlConverter.ToGuid(values[i]);
|
|
return guids;
|
|
}
|
|
if (type == typeof(UniqueId[]))
|
|
{
|
|
string[] values = (string[])ReadContentAs(typeof(string[]), namespaceResolver);
|
|
UniqueId[] uniqueIds = new UniqueId[values.Length];
|
|
for (int i = 0; i < values.Length; i++)
|
|
uniqueIds[i] = XmlConverter.ToUniqueId(values[i]);
|
|
return uniqueIds;
|
|
}
|
|
return base.ReadContentAs(type, namespaceResolver);
|
|
}
|
|
|
|
public virtual string ReadContentAsString(string[] strings, out int index)
|
|
{
|
|
if (strings == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("strings");
|
|
string s = ReadContentAsString();
|
|
index = -1;
|
|
for (int i = 0; i < strings.Length; i++)
|
|
{
|
|
string value = strings[i];
|
|
if (value == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(string.Format(CultureInfo.InvariantCulture, "strings[{0}]", i));
|
|
if (value == s)
|
|
{
|
|
index = i;
|
|
return value;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
public virtual string ReadContentAsString(XmlDictionaryString[] strings, out int index)
|
|
{
|
|
if (strings == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("strings");
|
|
string s = ReadContentAsString();
|
|
index = -1;
|
|
for (int i = 0; i < strings.Length; i++)
|
|
{
|
|
XmlDictionaryString value = strings[i];
|
|
if (value == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(string.Format(CultureInfo.InvariantCulture, "strings[{0}]", i));
|
|
if (value.Value == s)
|
|
{
|
|
index = i;
|
|
return value.Value;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
public override decimal ReadContentAsDecimal()
|
|
{
|
|
return XmlConverter.ToDecimal(ReadContentAsString());
|
|
}
|
|
|
|
public override Single ReadContentAsFloat()
|
|
{
|
|
return XmlConverter.ToSingle(ReadContentAsString());
|
|
}
|
|
|
|
public virtual UniqueId ReadContentAsUniqueId()
|
|
{
|
|
return XmlConverter.ToUniqueId(ReadContentAsString());
|
|
}
|
|
|
|
public virtual Guid ReadContentAsGuid()
|
|
{
|
|
return XmlConverter.ToGuid(ReadContentAsString());
|
|
}
|
|
|
|
public virtual TimeSpan ReadContentAsTimeSpan()
|
|
{
|
|
return XmlConverter.ToTimeSpan(ReadContentAsString());
|
|
}
|
|
|
|
public virtual void ReadContentAsQualifiedName(out string localName, out string namespaceUri)
|
|
{
|
|
string prefix;
|
|
XmlConverter.ToQualifiedName(ReadContentAsString(), out prefix, out localName);
|
|
namespaceUri = LookupNamespace(prefix);
|
|
if (namespaceUri == null)
|
|
XmlExceptionHelper.ThrowUndefinedPrefix(this, prefix);
|
|
}
|
|
|
|
/* string, bool, int, long, float, double, decimal, DateTime, base64, binhex, uniqueID, object, list*/
|
|
public override string ReadElementContentAsString()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
string value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
value = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsString();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public override bool ReadElementContentAsBoolean()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
bool value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
value = XmlConverter.ToBoolean(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsBoolean();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public override int ReadElementContentAsInt()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
int value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
value = XmlConverter.ToInt32(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsInt();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public override long ReadElementContentAsLong()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
long value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
value = XmlConverter.ToInt64(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsLong();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public override float ReadElementContentAsFloat()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
float value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
value = XmlConverter.ToSingle(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsFloat();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public override double ReadElementContentAsDouble()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
double value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
value = XmlConverter.ToDouble(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsDouble();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public override decimal ReadElementContentAsDecimal()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
decimal value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
value = XmlConverter.ToDecimal(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsDecimal();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public override DateTime ReadElementContentAsDateTime()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
DateTime value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
try
|
|
{
|
|
value = DateTime.Parse(string.Empty, NumberFormatInfo.InvariantInfo);
|
|
}
|
|
catch (ArgumentException exception)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(string.Empty, "DateTime", exception));
|
|
}
|
|
catch (FormatException exception)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(string.Empty, "DateTime", exception));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsDateTime();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public virtual UniqueId ReadElementContentAsUniqueId()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
UniqueId value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
try
|
|
{
|
|
value = new UniqueId(string.Empty);
|
|
}
|
|
catch (ArgumentException exception)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(string.Empty, "UniqueId", exception));
|
|
}
|
|
catch (FormatException exception)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(string.Empty, "UniqueId", exception));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsUniqueId();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
[SuppressMessage("Reliability", "Reliability113", Justification = "Catching expected exceptions inline instead of calling Fx.CreateGuid to minimize code change")]
|
|
public virtual Guid ReadElementContentAsGuid()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
Guid value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
try
|
|
{
|
|
value = Guid.Empty;
|
|
}
|
|
catch (ArgumentException exception)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(string.Empty, "Guid", exception));
|
|
}
|
|
catch (FormatException exception)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(string.Empty, "Guid", exception));
|
|
}
|
|
catch (OverflowException exception)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(string.Empty, "Guid", exception));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsGuid();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public virtual TimeSpan ReadElementContentAsTimeSpan()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
TimeSpan value;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
value = XmlConverter.ToTimeSpan(string.Empty);
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
value = ReadContentAsTimeSpan();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
public virtual byte[] ReadElementContentAsBase64()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
byte[] buffer;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
buffer = new byte[0];
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
buffer = ReadContentAsBase64();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
public virtual byte[] ReadElementContentAsBinHex()
|
|
{
|
|
bool isEmptyElement = IsStartElement() && IsEmptyElement;
|
|
byte[] buffer;
|
|
|
|
if (isEmptyElement)
|
|
{
|
|
Read();
|
|
buffer = new byte[0];
|
|
}
|
|
else
|
|
{
|
|
ReadStartElement();
|
|
buffer = ReadContentAsBinHex();
|
|
ReadEndElement();
|
|
}
|
|
|
|
return buffer;
|
|
}
|
|
|
|
public virtual void GetNonAtomizedNames(out string localName, out string namespaceUri)
|
|
{
|
|
localName = this.LocalName;
|
|
namespaceUri = this.NamespaceURI;
|
|
}
|
|
|
|
public virtual bool TryGetLocalNameAsDictionaryString(out XmlDictionaryString localName)
|
|
{
|
|
localName = null;
|
|
return false;
|
|
}
|
|
|
|
public virtual bool TryGetNamespaceUriAsDictionaryString(out XmlDictionaryString namespaceUri)
|
|
{
|
|
namespaceUri = null;
|
|
return false;
|
|
}
|
|
|
|
public virtual bool TryGetValueAsDictionaryString(out XmlDictionaryString value)
|
|
{
|
|
value = null;
|
|
return false;
|
|
}
|
|
|
|
void CheckArray(Array array, int offset, int count)
|
|
{
|
|
if (array == null)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("array"));
|
|
if (offset < 0)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.ValueMustBeNonNegative)));
|
|
if (offset > array.Length)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.OffsetExceedsBufferSize, array.Length)));
|
|
if (count < 0)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.ValueMustBeNonNegative)));
|
|
if (count > array.Length - offset)
|
|
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.SizeExceedsRemainingBufferSpace, array.Length - offset)));
|
|
}
|
|
|
|
public virtual bool IsStartArray(out Type type)
|
|
{
|
|
type = null;
|
|
return false;
|
|
}
|
|
|
|
public virtual bool TryGetArrayLength(out int count)
|
|
{
|
|
count = 0;
|
|
return false;
|
|
}
|
|
|
|
// Boolean
|
|
public virtual bool[] ReadBooleanArray(string localName, string namespaceUri)
|
|
{
|
|
return BooleanArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual bool[] ReadBooleanArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return BooleanArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, bool[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsBoolean();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, bool[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// Int16
|
|
public virtual Int16[] ReadInt16Array(string localName, string namespaceUri)
|
|
{
|
|
return Int16ArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual Int16[] ReadInt16Array(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return Int16ArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, Int16[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
int i = ReadElementContentAsInt();
|
|
if (i < Int16.MinValue || i > Int16.MaxValue)
|
|
XmlExceptionHelper.ThrowConversionOverflow(this, i.ToString(NumberFormatInfo.CurrentInfo), "Int16");
|
|
array[offset + actual] = (Int16)i;
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Int16[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// Int32
|
|
public virtual Int32[] ReadInt32Array(string localName, string namespaceUri)
|
|
{
|
|
return Int32ArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual Int32[] ReadInt32Array(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return Int32ArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, Int32[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsInt();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Int32[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// Int64
|
|
public virtual Int64[] ReadInt64Array(string localName, string namespaceUri)
|
|
{
|
|
return Int64ArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual Int64[] ReadInt64Array(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return Int64ArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, Int64[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsLong();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Int64[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// Single
|
|
public virtual float[] ReadSingleArray(string localName, string namespaceUri)
|
|
{
|
|
return SingleArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual float[] ReadSingleArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return SingleArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, float[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsFloat();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, float[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// Double
|
|
public virtual double[] ReadDoubleArray(string localName, string namespaceUri)
|
|
{
|
|
return DoubleArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual double[] ReadDoubleArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return DoubleArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, double[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsDouble();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, double[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// Decimal
|
|
public virtual decimal[] ReadDecimalArray(string localName, string namespaceUri)
|
|
{
|
|
return DecimalArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual decimal[] ReadDecimalArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return DecimalArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, decimal[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsDecimal();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, decimal[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// DateTime
|
|
public virtual DateTime[] ReadDateTimeArray(string localName, string namespaceUri)
|
|
{
|
|
return DateTimeArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual DateTime[] ReadDateTimeArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return DateTimeArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, DateTime[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsDateTime();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, DateTime[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// Guid
|
|
public virtual Guid[] ReadGuidArray(string localName, string namespaceUri)
|
|
{
|
|
return GuidArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual Guid[] ReadGuidArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return GuidArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, Guid[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsGuid();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, Guid[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
// TimeSpan
|
|
public virtual TimeSpan[] ReadTimeSpanArray(string localName, string namespaceUri)
|
|
{
|
|
return TimeSpanArrayHelperWithString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual TimeSpan[] ReadTimeSpanArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
|
|
{
|
|
return TimeSpanArrayHelperWithDictionaryString.Instance.ReadArray(this, localName, namespaceUri, Quotas.MaxArrayLength);
|
|
}
|
|
|
|
public virtual int ReadArray(string localName, string namespaceUri, TimeSpan[] array, int offset, int count)
|
|
{
|
|
CheckArray(array, offset, count);
|
|
int actual = 0;
|
|
while (actual < count && IsStartElement(localName, namespaceUri))
|
|
{
|
|
array[offset + actual] = ReadElementContentAsTimeSpan();
|
|
actual++;
|
|
}
|
|
return actual;
|
|
}
|
|
|
|
public virtual int ReadArray(XmlDictionaryString localName, XmlDictionaryString namespaceUri, TimeSpan[] array, int offset, int count)
|
|
{
|
|
return ReadArray(XmlDictionaryString.GetString(localName), XmlDictionaryString.GetString(namespaceUri), array, offset, count);
|
|
}
|
|
|
|
class XmlWrappedReader : XmlDictionaryReader, IXmlLineInfo
|
|
{
|
|
XmlReader reader;
|
|
XmlNamespaceManager nsMgr;
|
|
|
|
public XmlWrappedReader(XmlReader reader, XmlNamespaceManager nsMgr)
|
|
{
|
|
this.reader = reader;
|
|
this.nsMgr = nsMgr;
|
|
}
|
|
|
|
public override int AttributeCount
|
|
{
|
|
get
|
|
{
|
|
return reader.AttributeCount;
|
|
}
|
|
}
|
|
|
|
public override string BaseURI
|
|
{
|
|
get
|
|
{
|
|
return reader.BaseURI;
|
|
}
|
|
}
|
|
|
|
public override bool CanReadBinaryContent
|
|
{
|
|
get { return reader.CanReadBinaryContent; }
|
|
}
|
|
|
|
public override bool CanReadValueChunk
|
|
{
|
|
get { return reader.CanReadValueChunk; }
|
|
}
|
|
|
|
public override void Close()
|
|
{
|
|
reader.Close();
|
|
nsMgr = null;
|
|
}
|
|
|
|
public override int Depth
|
|
{
|
|
get
|
|
{
|
|
return reader.Depth;
|
|
}
|
|
}
|
|
|
|
public override bool EOF
|
|
{
|
|
get
|
|
{
|
|
return reader.EOF;
|
|
}
|
|
}
|
|
|
|
public override string GetAttribute(int index)
|
|
{
|
|
return reader.GetAttribute(index);
|
|
}
|
|
|
|
public override string GetAttribute(string name)
|
|
{
|
|
return reader.GetAttribute(name);
|
|
}
|
|
|
|
public override string GetAttribute(string name, string namespaceUri)
|
|
{
|
|
return reader.GetAttribute(name, namespaceUri);
|
|
}
|
|
|
|
public override bool HasValue
|
|
{
|
|
get
|
|
{
|
|
return reader.HasValue;
|
|
}
|
|
}
|
|
|
|
public override bool IsDefault
|
|
{
|
|
get
|
|
{
|
|
return reader.IsDefault;
|
|
}
|
|
}
|
|
|
|
public override bool IsEmptyElement
|
|
{
|
|
get
|
|
{
|
|
return reader.IsEmptyElement;
|
|
}
|
|
}
|
|
|
|
public override bool IsStartElement(string name)
|
|
{
|
|
return reader.IsStartElement(name);
|
|
}
|
|
|
|
public override bool IsStartElement(string localName, string namespaceUri)
|
|
{
|
|
return reader.IsStartElement(localName, namespaceUri);
|
|
}
|
|
|
|
public override string LocalName
|
|
{
|
|
get
|
|
{
|
|
return reader.LocalName;
|
|
}
|
|
}
|
|
|
|
public override string LookupNamespace(string namespaceUri)
|
|
{
|
|
return reader.LookupNamespace(namespaceUri);
|
|
}
|
|
|
|
public override void MoveToAttribute(int index)
|
|
{
|
|
reader.MoveToAttribute(index);
|
|
}
|
|
|
|
public override bool MoveToAttribute(string name)
|
|
{
|
|
return reader.MoveToAttribute(name);
|
|
}
|
|
|
|
public override bool MoveToAttribute(string name, string namespaceUri)
|
|
{
|
|
return reader.MoveToAttribute(name, namespaceUri);
|
|
}
|
|
|
|
public override bool MoveToElement()
|
|
{
|
|
return reader.MoveToElement();
|
|
}
|
|
|
|
public override bool MoveToFirstAttribute()
|
|
{
|
|
return reader.MoveToFirstAttribute();
|
|
}
|
|
|
|
public override bool MoveToNextAttribute()
|
|
{
|
|
return reader.MoveToNextAttribute();
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
return reader.Name;
|
|
}
|
|
}
|
|
|
|
public override string NamespaceURI
|
|
{
|
|
get
|
|
{
|
|
return reader.NamespaceURI;
|
|
}
|
|
}
|
|
|
|
public override XmlNameTable NameTable
|
|
{
|
|
get
|
|
{
|
|
return reader.NameTable;
|
|
}
|
|
}
|
|
|
|
public override XmlNodeType NodeType
|
|
{
|
|
get
|
|
{
|
|
return reader.NodeType;
|
|
}
|
|
}
|
|
|
|
public override string Prefix
|
|
{
|
|
get
|
|
{
|
|
return reader.Prefix;
|
|
}
|
|
}
|
|
|
|
public override char QuoteChar
|
|
{
|
|
get
|
|
{
|
|
return reader.QuoteChar;
|
|
}
|
|
}
|
|
|
|
public override bool Read()
|
|
{
|
|
return reader.Read();
|
|
}
|
|
|
|
public override bool ReadAttributeValue()
|
|
{
|
|
return reader.ReadAttributeValue();
|
|
}
|
|
|
|
public override string ReadElementString(string name)
|
|
{
|
|
return reader.ReadElementString(name);
|
|
}
|
|
|
|
public override string ReadElementString(string localName, string namespaceUri)
|
|
{
|
|
return reader.ReadElementString(localName, namespaceUri);
|
|
}
|
|
|
|
public override string ReadInnerXml()
|
|
{
|
|
return reader.ReadInnerXml();
|
|
}
|
|
|
|
public override string ReadOuterXml()
|
|
{
|
|
return reader.ReadOuterXml();
|
|
}
|
|
|
|
public override void ReadStartElement(string name)
|
|
{
|
|
reader.ReadStartElement(name);
|
|
}
|
|
|
|
public override void ReadStartElement(string localName, string namespaceUri)
|
|
{
|
|
reader.ReadStartElement(localName, namespaceUri);
|
|
}
|
|
|
|
public override void ReadEndElement()
|
|
{
|
|
reader.ReadEndElement();
|
|
}
|
|
|
|
public override string ReadString()
|
|
{
|
|
return reader.ReadString();
|
|
}
|
|
|
|
public override ReadState ReadState
|
|
{
|
|
get
|
|
{
|
|
return reader.ReadState;
|
|
}
|
|
}
|
|
|
|
public override void ResolveEntity()
|
|
{
|
|
reader.ResolveEntity();
|
|
}
|
|
|
|
public override string this[int index]
|
|
{
|
|
get
|
|
{
|
|
return reader[index];
|
|
}
|
|
}
|
|
|
|
public override string this[string name]
|
|
{
|
|
get
|
|
{
|
|
return reader[name];
|
|
}
|
|
}
|
|
|
|
public override string this[string name, string namespaceUri]
|
|
{
|
|
get
|
|
{
|
|
return reader[name, namespaceUri];
|
|
}
|
|
}
|
|
|
|
public override string Value
|
|
{
|
|
get
|
|
{
|
|
return reader.Value;
|
|
}
|
|
}
|
|
|
|
public override string XmlLang
|
|
{
|
|
get
|
|
{
|
|
return reader.XmlLang;
|
|
}
|
|
}
|
|
|
|
public override XmlSpace XmlSpace
|
|
{
|
|
get
|
|
{
|
|
return reader.XmlSpace;
|
|
}
|
|
}
|
|
|
|
public override int ReadElementContentAsBase64(byte[] buffer, int offset, int count)
|
|
{
|
|
return reader.ReadElementContentAsBase64(buffer, offset, count);
|
|
}
|
|
|
|
public override int ReadContentAsBase64(byte[] buffer, int offset, int count)
|
|
{
|
|
return reader.ReadContentAsBase64(buffer, offset, count);
|
|
}
|
|
|
|
public override int ReadElementContentAsBinHex(byte[] buffer, int offset, int count)
|
|
{
|
|
return reader.ReadElementContentAsBinHex(buffer, offset, count);
|
|
}
|
|
|
|
public override int ReadContentAsBinHex(byte[] buffer, int offset, int count)
|
|
{
|
|
return reader.ReadContentAsBinHex(buffer, offset, count);
|
|
}
|
|
|
|
public override int ReadValueChunk(char[] chars, int offset, int count)
|
|
{
|
|
return reader.ReadValueChunk(chars, offset, count);
|
|
}
|
|
|
|
public override Type ValueType
|
|
{
|
|
get
|
|
{
|
|
return reader.ValueType;
|
|
}
|
|
}
|
|
|
|
public override Boolean ReadContentAsBoolean()
|
|
{
|
|
return reader.ReadContentAsBoolean();
|
|
}
|
|
|
|
public override DateTime ReadContentAsDateTime()
|
|
{
|
|
return reader.ReadContentAsDateTime();
|
|
}
|
|
|
|
public override Decimal ReadContentAsDecimal()
|
|
{
|
|
// return reader.ReadContentAsDecimal();
|
|
return (Decimal)reader.ReadContentAs(typeof(Decimal), null);
|
|
}
|
|
|
|
public override Double ReadContentAsDouble()
|
|
{
|
|
return reader.ReadContentAsDouble();
|
|
}
|
|
|
|
public override Int32 ReadContentAsInt()
|
|
{
|
|
return reader.ReadContentAsInt();
|
|
}
|
|
|
|
public override Int64 ReadContentAsLong()
|
|
{
|
|
return reader.ReadContentAsLong();
|
|
}
|
|
|
|
public override Single ReadContentAsFloat()
|
|
{
|
|
return reader.ReadContentAsFloat();
|
|
}
|
|
|
|
public override string ReadContentAsString()
|
|
{
|
|
return reader.ReadContentAsString();
|
|
}
|
|
|
|
public override object ReadContentAs(Type type, IXmlNamespaceResolver namespaceResolver)
|
|
{
|
|
return reader.ReadContentAs(type, namespaceResolver);
|
|
}
|
|
|
|
public bool HasLineInfo()
|
|
{
|
|
IXmlLineInfo lineInfo = reader as IXmlLineInfo;
|
|
|
|
if (lineInfo == null)
|
|
return false;
|
|
|
|
return lineInfo.HasLineInfo();
|
|
}
|
|
|
|
public int LineNumber
|
|
{
|
|
get
|
|
{
|
|
IXmlLineInfo lineInfo = reader as IXmlLineInfo;
|
|
|
|
if (lineInfo == null)
|
|
return 1;
|
|
|
|
return lineInfo.LineNumber;
|
|
}
|
|
}
|
|
|
|
public int LinePosition
|
|
{
|
|
get
|
|
{
|
|
IXmlLineInfo lineInfo = reader as IXmlLineInfo;
|
|
|
|
if (lineInfo == null)
|
|
return 1;
|
|
|
|
return lineInfo.LinePosition;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|