using System;
using System.IO;
using Cpp2IlInjected;
namespace System.Xml
{
/// Represents a writer that provides a fast, non-cached, forward-only way to generate streams or files that contain XML data.
// Token: 0x02000099 RID: 153
[Token(Token = "0x2000099")]
public abstract class XmlWriter : IDisposable
{
/// When overridden in a derived class, writes the XML declaration with the version "1.0".
/// This is not the first write method called after the constructor.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000715 RID: 1813
[Token(Token = "0x6000715")]
[Address(Slot = "5")]
public abstract void WriteStartDocument();
/// When overridden in a derived class, writes the XML declaration with the version "1.0" and the standalone attribute.
/// If , it writes "standalone=yes"; if , it writes "standalone=no".
/// This is not the first write method called after the constructor.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000716 RID: 1814
[Token(Token = "0x6000716")]
[Address(Slot = "6")]
public abstract void WriteStartDocument(bool standalone);
/// When overridden in a derived class, closes any open elements or attributes and puts the writer back in the Start state.
/// The XML document is invalid.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000717 RID: 1815
[Token(Token = "0x6000717")]
[Address(Slot = "7")]
public abstract void WriteEndDocument();
/// When overridden in a derived class, writes the DOCTYPE declaration with the specified name and optional attributes.
/// The name of the DOCTYPE. This must be non-empty.
/// If non-null it also writes PUBLIC "pubid" "sysid" where and are replaced with the value of the given arguments.
/// If is and is non-null it writes SYSTEM "sysid" where is replaced with the value of this argument.
/// If non-null it writes [subset] where subset is replaced with the value of this argument.
/// This method was called outside the prolog (after the root element).
/// The value for would result in invalid XML.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000718 RID: 1816
[Token(Token = "0x6000718")]
[Address(Slot = "8")]
public abstract void WriteDocType(string name, string pubid, string sysid, string subset);
/// When overridden in a derived class, writes the specified start tag and associates it with the given namespace.
/// The local name of the element.
/// The namespace URI to associate with the element. If this namespace is already in scope and has an associated prefix, the writer automatically writes that prefix also.
/// The writer is closed.
/// There is a character in the buffer that is a valid XML character but is not valid for the output encoding. For example, if the output encoding is ASCII, you should only use characters from the range of 0 to 127 for element and attribute names. The invalid character might be in the argument of this method or in an argument of previous methods that were writing to the buffer. Such characters are escaped by character entity references when possible (for example, in text nodes or attribute values). However, the character entity reference is not allowed in element and attribute names, comments, processing instructions, or CDATA sections.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000719 RID: 1817 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000719")]
[Address(RVA = "0xAD9490", Offset = "0xAD8490", VA = "0x180AD9490")]
public void WriteStartElement(string localName, string ns)
{
}
/// When overridden in a derived class, writes the specified start tag and associates it with the given namespace and prefix.
/// The namespace prefix of the element.
/// The local name of the element.
/// The namespace URI to associate with the element.
/// The writer is closed.
/// There is a character in the buffer that is a valid XML character but is not valid for the output encoding. For example, if the output encoding is ASCII, you should only use characters from the range of 0 to 127 for element and attribute names. The invalid character might be in the argument of this method or in an argument of previous methods that were writing to the buffer. Such characters are escaped by character entity references when possible (for example, in text nodes or attribute values). However, the character entity reference is not allowed in element and attribute names, comments, processing instructions, or CDATA sections.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600071A RID: 1818
[Token(Token = "0x600071A")]
[Address(Slot = "9")]
public abstract void WriteStartElement(string prefix, string localName, string ns);
/// When overridden in a derived class, closes one element and pops the corresponding namespace scope.
/// This results in an invalid XML document.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600071B RID: 1819
[Token(Token = "0x600071B")]
[Address(Slot = "10")]
public abstract void WriteEndElement();
/// When overridden in a derived class, closes one element and pops the corresponding namespace scope.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600071C RID: 1820
[Token(Token = "0x600071C")]
[Address(Slot = "11")]
public abstract void WriteFullEndElement();
/// When overridden in a derived class, writes an attribute with the specified local name, namespace URI, and value.
/// The local name of the attribute.
/// The namespace URI to associate with the attribute.
/// The value of the attribute.
/// The state of writer is not or writer is closed.
/// The or attribute value is invalid.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600071D RID: 1821 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x600071D")]
[Address(RVA = "0xAD8BA0", Offset = "0xAD7BA0", VA = "0x180AD8BA0")]
public void WriteAttributeString(string localName, string ns, string value)
{
}
/// When overridden in a derived class, writes out the attribute with the specified local name and value.
/// The local name of the attribute.
/// The value of the attribute.
/// The state of writer is not or writer is closed.
/// The or attribute value is invalid.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600071E RID: 1822 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x600071E")]
[Address(RVA = "0xAD8B30", Offset = "0xAD7B30", VA = "0x180AD8B30")]
public void WriteAttributeString(string localName, string value)
{
}
/// When overridden in a derived class, writes out the attribute with the specified prefix, local name, namespace URI, and value.
/// The namespace prefix of the attribute.
/// The local name of the attribute.
/// The namespace URI of the attribute.
/// The value of the attribute.
/// The state of writer is not or writer is closed.
/// The or attribute value is invalid.
/// The or is .
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600071F RID: 1823 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x600071F")]
[Address(RVA = "0xAD8C10", Offset = "0xAD7C10", VA = "0x180AD8C10")]
public void WriteAttributeString(string prefix, string localName, string ns, string value)
{
}
/// When overridden in a derived class, writes the start of an attribute with the specified prefix, local name, and namespace URI.
/// The namespace prefix of the attribute.
/// The local name of the attribute.
/// The namespace URI for the attribute.
/// There is a character in the buffer that is a valid XML character but is not valid for the output encoding. For example, if the output encoding is ASCII, you should only use characters from the range of 0 to 127 for element and attribute names. The invalid character might be in the argument of this method or in an argument of previous methods that were writing to the buffer. Such characters are escaped by character entity references when possible (for example, in text nodes or attribute values). However, the character entity reference is not allowed in element and attribute names, comments, processing instructions, or CDATA sections.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000720 RID: 1824
[Token(Token = "0x6000720")]
[Address(Slot = "12")]
public abstract void WriteStartAttribute(string prefix, string localName, string ns);
/// When overridden in a derived class, closes the previous call.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000721 RID: 1825
[Token(Token = "0x6000721")]
[Address(Slot = "13")]
public abstract void WriteEndAttribute();
/// When overridden in a derived class, writes out a <![CDATA[...]]> block containing the specified text.
/// The text to place inside the CDATA block.
/// The text would result in a non-well formed XML document.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000722 RID: 1826
[Token(Token = "0x6000722")]
[Address(Slot = "14")]
public abstract void WriteCData(string text);
/// When overridden in a derived class, writes out a comment <!--...--> containing the specified text.
/// Text to place inside the comment.
/// The text would result in a non-well-formed XML document.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000723 RID: 1827
[Token(Token = "0x6000723")]
[Address(Slot = "15")]
public abstract void WriteComment(string text);
/// When overridden in a derived class, writes out a processing instruction with a space between the name and text as follows: <?name text?>.
/// The name of the processing instruction.
/// The text to include in the processing instruction.
/// The text would result in a non-well formed XML document.
/// is either or .This method is being used to create an XML declaration after has already been called.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000724 RID: 1828
[Token(Token = "0x6000724")]
[Address(Slot = "16")]
public abstract void WriteProcessingInstruction(string name, string text);
/// When overridden in a derived class, writes out an entity reference as .
/// The name of the entity reference.
///
/// is either or .
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000725 RID: 1829
[Token(Token = "0x6000725")]
[Address(Slot = "17")]
public abstract void WriteEntityRef(string name);
/// When overridden in a derived class, forces the generation of a character entity for the specified Unicode character value.
/// The Unicode character for which to generate a character entity.
/// The character is in the surrogate pair character range, - .
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000726 RID: 1830
[Token(Token = "0x6000726")]
[Address(Slot = "18")]
public abstract void WriteCharEntity(char ch);
/// When overridden in a derived class, writes out the given white space.
/// The string of white space characters.
/// The string contains non-white space characters.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000727 RID: 1831
[Token(Token = "0x6000727")]
[Address(Slot = "19")]
public abstract void WriteWhitespace(string ws);
/// When overridden in a derived class, writes the given text content.
/// The text to write.
/// The text string contains an invalid surrogate pair.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000728 RID: 1832
[Token(Token = "0x6000728")]
[Address(Slot = "20")]
public abstract void WriteString(string text);
/// When overridden in a derived class, generates and writes the surrogate character entity for the surrogate character pair.
/// The low surrogate. This must be a value between 0xDC00 and 0xDFFF.
/// The high surrogate. This must be a value between 0xD800 and 0xDBFF.
/// An invalid surrogate character pair was passed.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000729 RID: 1833
[Token(Token = "0x6000729")]
[Address(Slot = "21")]
public abstract void WriteSurrogateCharEntity(char lowChar, char highChar);
/// When overridden in a derived class, writes text one buffer at a time.
/// Character array containing the text to write.
/// The position in the buffer indicating the start of the text to write.
/// The number of characters to write.
///
/// is .
///
/// or is less than zero.-or-The buffer length minus is less than ; the call results in surrogate pair characters being split or an invalid surrogate pair being written.
/// The parameter value is not valid.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600072A RID: 1834
[Token(Token = "0x600072A")]
[Address(Slot = "22")]
public abstract void WriteChars(char[] buffer, int index, int count);
/// When overridden in a derived class, writes raw markup manually from a character buffer.
/// Character array containing the text to write.
/// The position within the buffer indicating the start of the text to write.
/// The number of characters to write.
///
/// is .
///
/// or is less than zero. -or-The buffer length minus is less than .
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600072B RID: 1835
[Token(Token = "0x600072B")]
[Address(Slot = "23")]
public abstract void WriteRaw(char[] buffer, int index, int count);
/// When overridden in a derived class, writes raw markup manually from a string.
/// String containing the text to write.
///
/// is either or .
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600072C RID: 1836
[Token(Token = "0x600072C")]
[Address(Slot = "24")]
public abstract void WriteRaw(string data);
/// When overridden in a derived class, encodes the specified binary bytes as Base64 and writes out the resulting text.
/// Byte array to encode.
/// The position in the buffer indicating the start of the bytes to write.
/// The number of bytes to write.
///
/// is .
///
/// or is less than zero. -or-The buffer length minus is less than .
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600072D RID: 1837
[Token(Token = "0x600072D")]
[Address(Slot = "25")]
public abstract void WriteBase64(byte[] buffer, int index, int count);
/// When overridden in a derived class, encodes the specified binary bytes as and writes out the resulting text.
/// Byte array to encode.
/// The position in the buffer indicating the start of the bytes to write.
/// The number of bytes to write.
///
/// is .
/// The writer is closed or in error state.
///
/// or is less than zero. -or-The buffer length minus is less than .
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x0600072E RID: 1838 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x600072E")]
[Address(RVA = "0xAD8F20", Offset = "0xAD7F20", VA = "0x180AD8F20", Slot = "26")]
public virtual void WriteBinHex(byte[] buffer, int index, int count)
{
}
/// When overridden in a derived class, gets the state of the writer.
/// One of the values.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x170001B5 RID: 437
// (get) Token: 0x0600072F RID: 1839
[Token(Token = "0x170001B5")]
public abstract WriteState WriteState
{
[Token(Token = "0x600072F")]
[Address(Slot = "27")]
get;
}
/// When overridden in a derived class, closes this stream and the underlying stream.
/// A call is made to write more output after has been called or the result of this call is an invalid XML document.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000730 RID: 1840 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000730")]
[Address(RVA = "0x4242D0", Offset = "0x4232D0", VA = "0x1804242D0", Slot = "28")]
public virtual void Close()
{
}
/// When overridden in a derived class, flushes whatever is in the buffer to the underlying streams and also flushes the underlying stream.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000731 RID: 1841
[Token(Token = "0x6000731")]
[Address(Slot = "29")]
public abstract void Flush();
/// When overridden in a derived class, returns the closest prefix defined in the current namespace scope for the namespace URI.
/// The namespace URI whose prefix you want to find.
/// The matching prefix or if no matching namespace URI is found in the current scope.
///
/// is either or .
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000732 RID: 1842
[Token(Token = "0x6000732")]
[Address(Slot = "30")]
public abstract string LookupPrefix(string ns);
/// Writes a value.
/// The value to write.
/// An invalid value was specified.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000733 RID: 1843 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000733")]
[Address(RVA = "0xAD94C0", Offset = "0xAD84C0", VA = "0x180AD94C0", Slot = "31")]
public virtual void WriteValue(string value)
{
}
/// When overridden in a derived class, writes out all the attributes found at the current position in the .
/// The from which to copy the attributes.
///
/// to copy the default attributes from the ; otherwise, .
///
/// is .
/// The reader is not positioned on an , or node.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000734 RID: 1844 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000734")]
[Address(RVA = "0xAD8C60", Offset = "0xAD7C60", VA = "0x180AD8C60", Slot = "32")]
public virtual void WriteAttributes(XmlReader reader, bool defattr)
{
}
/// When overridden in a derived class, copies everything from the reader to the writer and moves the reader to the start of the next sibling.
/// The to read from.
///
/// to copy the default attributes from the ; otherwise, .
///
/// is .
///
/// contains invalid characters.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000735 RID: 1845 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000735")]
[Address(RVA = "0xAD8FC0", Offset = "0xAD7FC0", VA = "0x180AD8FC0", Slot = "33")]
public virtual void WriteNode(XmlReader reader, bool defattr)
{
}
/// Writes an element with the specified local name, namespace URI, and value.
/// The local name of the element.
/// The namespace URI to associate with the element.
/// The value of the element.
/// The value is or an empty string.-or-The parameter values are not valid.
/// There is a character in the buffer that is a valid XML character but is not valid for the output encoding. For example, if the output encoding is ASCII, you should only use characters from the range of 0 to 127 for element and attribute names. The invalid character might be in the argument of this method or in an argument of previous methods that were writing to the buffer. Such characters are escaped by character entity references when possible (for example, in text nodes or attribute values). However, the character entity reference is not allowed in element and attribute names, comments, processing instructions, or CDATA sections.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000736 RID: 1846 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000736")]
[Address(RVA = "0xAD8F50", Offset = "0xAD7F50", VA = "0x180AD8F50")]
public void WriteElementString(string localName, string ns, string value)
{
}
/// Releases all resources used by the current instance of the class.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000737 RID: 1847 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000737")]
[Address(RVA = "0xAD8AD0", Offset = "0xAD7AD0", VA = "0x180AD8AD0", Slot = "4")]
public void Dispose()
{
}
/// Releases the unmanaged resources used by the and optionally releases the managed resources.
///
/// to release both managed and unmanaged resources; to release only unmanaged resources.
/// An method was called before a previous asynchronous operation finished. In this case, is thrown with the message “An asynchronous operation is already in progress.”
// Token: 0x06000738 RID: 1848 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x6000738")]
[Address(RVA = "0xAD8AF0", Offset = "0xAD7AF0", VA = "0x180AD8AF0", Slot = "34")]
protected virtual void Dispose(bool disposing)
{
}
/// Creates a new instance using the stream and object.
/// The stream to which you want to write. The writes XML 1.0 text syntax and appends it to the specified stream.
/// The object used to configure the new instance. If this is , a with default settings is used.If the is being used with the method, you should use the property to obtain an object with the correct settings. This ensures that the created object has the correct output settings.
/// An object.
/// The value is .
// Token: 0x06000739 RID: 1849 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6000739")]
[Address(RVA = "0xAD89F0", Offset = "0xAD79F0", VA = "0x180AD89F0")]
public static XmlWriter Create(Stream output, XmlWriterSettings settings)
{
return null;
}
/// Creates a new instance using the and objects.
/// The to which you want to write. The writes XML 1.0 text syntax and appends it to the specified .
/// The object used to configure the new instance. If this is , a with default settings is used.If the is being used with the method, you should use the property to obtain an object with the correct settings. This ensures that the created object has the correct output settings.
/// An object.
/// The value is .
// Token: 0x0600073A RID: 1850 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x600073A")]
[Address(RVA = "0xAD8A60", Offset = "0xAD7A60", VA = "0x180AD8A60")]
public static XmlWriter Create(TextWriter output, XmlWriterSettings settings)
{
return null;
}
/// Initializes a new instance of the class.
// Token: 0x0600073B RID: 1851 RVA: 0x00002053 File Offset: 0x00000253
[Token(Token = "0x600073B")]
[Address(RVA = "0x412370", Offset = "0x411370", VA = "0x180412370")]
protected XmlWriter()
{
}
// Token: 0x0400045B RID: 1115
[FieldOffset(Offset = "0x10")]
[Token(Token = "0x400045B")]
private char[] writeNodeBuffer;
}
}