public QueryOutputWriter(XmlRawWriter writer, XmlWriterSettings settings)
{
this.wrapped = writer;
this.systemId = settings.DocTypeSystem;
this.publicId = settings.DocTypePublic;
if (settings.OutputMethod == XmlOutputMethod.Xml)
{
if (this.systemId != null)
{
this.outputDocType = true;
this.checkWellFormedDoc = true;
}
if (settings.AutoXmlDeclaration && (settings.Standalone == XmlStandalone.Yes))
{
this.checkWellFormedDoc = true;
}
if (settings.CDataSectionElements.Count > 0)
{
this.bitsCData = new BitStack();
this.lookupCDataElems = new Dictionary <XmlQualifiedName, int>();
this.qnameCData = new XmlQualifiedName();
foreach (XmlQualifiedName name in settings.CDataSectionElements)
{
this.lookupCDataElems[name] = 0;
}
this.bitsCData.PushBit(false);
}
}
else if ((settings.OutputMethod == XmlOutputMethod.Html) && ((this.systemId != null) || (this.publicId != null)))
{
this.outputDocType = true;
}
}
public QueryOutputWriter(XmlRawWriter writer, XmlWriterSettings settings)
{
this.wrapped = writer;
this.systemId = settings.DocTypeSystem;
this.publicId = settings.DocTypePublic;
if (settings.OutputMethod == XmlOutputMethod.Xml)
{
if (this.systemId != null)
{
this.outputDocType = true;
this.checkWellFormedDoc = true;
}
if (settings.AutoXmlDeclaration && (settings.Standalone == XmlStandalone.Yes))
{
this.checkWellFormedDoc = true;
}
if (settings.CDataSectionElements.Count > 0)
{
this.bitsCData = new BitStack();
this.lookupCDataElems = new Dictionary<XmlQualifiedName, int>();
this.qnameCData = new XmlQualifiedName();
foreach (XmlQualifiedName name in settings.CDataSectionElements)
{
this.lookupCDataElems[name] = 0;
}
this.bitsCData.PushBit(false);
}
}
else if ((settings.OutputMethod == XmlOutputMethod.Html) && ((this.systemId != null) || (this.publicId != null)))
{
this.outputDocType = true;
}
}
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// Initialize output state to accept Rtf content (top-level sequences are therefore prohibited).
/// </summary>
internal XmlQueryOutput(XmlQueryRuntime runtime, XmlEventCache xwrt) {
this.runtime = runtime;
this.xwrt = xwrt;
this.xstate = XmlState.WithinContent;
this.depth = 1;
this.rootType = XPathNodeType.Root;
}
/// <summary>
/// Create either the Html or Xml writer and send any cached events to it.
/// </summary>
private void CreateWrappedWriter(XmlOutputMethod outMethod)
{
Debug.Assert(_wrapped == null);
// Create either the Xml or Html writer
_writerSettings.ReadOnly = false;
_writerSettings.OutputMethod = outMethod;
// If Indent was not set by the user, then default to True for Html
if (outMethod == XmlOutputMethod.Html && _writerSettings.IndentInternal == TriState.Unknown)
{
_writerSettings.Indent = true;
}
_writerSettings.ReadOnly = true;
if (_textWriter != null)
{
_wrapped = ((XmlWellFormedWriter)XmlWriter.Create(_textWriter, _writerSettings)).RawWriter;
}
else
{
_wrapped = ((XmlWellFormedWriter)XmlWriter.Create(_strm, _writerSettings)).RawWriter;
}
// Send cached events to the new writer
_eventCache.EndEvents();
_eventCache.EventsToWriter(_wrapped);
// Send OnRemoveWriter event
if (_onRemove != null)
{
(this._onRemove)(_wrapped);
}
}
/// <summary>
/// The wrapped writer will callback on this method if it wishes to remove itself from the pipeline.
/// </summary>
private void SetWrappedWriter(XmlRawWriter writer) {
// If new writer might remove itself from pipeline, have it callback on this method when its ready to go
IRemovableWriter removable = writer as IRemovableWriter;
if (removable != null)
removable.OnRemoveWriterEvent = SetWrappedWriter;
this.wrapped = writer;
}
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// Initialize output state to accept Rtf content (top-level sequences are therefore prohibited).
/// </summary>
internal XmlQueryOutput(XmlQueryRuntime runtime, XmlEventCache xwrt)
{
_runtime = runtime;
_xwrt = xwrt;
_xstate = XmlState.WithinContent;
_depth = 1;
_rootType = XPathNodeType.Root;
}
/// <summary>
/// Start construction of a new Xml tree (document or fragment).
/// </summary>
public override XmlRawWriter StartTree(XPathNodeType rootType, IXmlNamespaceResolver nsResolver, XmlNameTable nameTable) {
// Build XPathDocument
// If rootType != XPathNodeType.Root, then build an XQuery fragment
this.doc = new XPathDocument(nameTable);
this.writer = doc.LoadFromWriter(XPathDocument.LoadFlags.AtomizeNames | (rootType == XPathNodeType.Root ? XPathDocument.LoadFlags.None : XPathDocument.LoadFlags.Fragment), string.Empty);
this.writer.NamespaceResolver = nsResolver;
return this.writer;
}
private int hashCodeUnion; // Set of hash bits that can quickly guarantee a name is not a duplicate
/// <summary>
/// Initialize the cache. Use this method instead of a constructor in order to reuse the cache.
/// </summary>
public void Init(XmlRawWriter wrapped) {
SetWrappedWriter(wrapped);
// Clear attribute list
this.numEntries = 0;
this.idxLastName = 0;
this.hashCodeUnion = 0;
}
public QueryOutputWriter(XmlRawWriter writer, XmlWriterSettings settings)
{
this.wrapped = writer;
this.systemId = settings.DocTypeSystem;
this.publicId = settings.DocTypePublic;
if (settings.OutputMethod == XmlOutputMethod.Xml)
{
// Xml output method shouldn't output doc-type-decl if system ID is not defined (even if public ID is)
// Only check for well-formed document if output method is xml
if (this.systemId != null)
{
this.outputDocType = true;
this.checkWellFormedDoc = true;
}
// Check for well-formed document if standalone="yes" in an auto-generated xml declaration
if (settings.AutoXmlDeclaration && settings.Standalone == XmlStandalone.Yes)
{
this.checkWellFormedDoc = true;
}
this.listCDataElems = settings.CDataSectionElements;
if (this.listCDataElems != null)
{
this.bitsCData = new BitStack();
this.lookupCDataElems = new Hashtable();
this.qnameCData = new XmlQualifiedName();
// Add each element name to the lookup table
foreach (object name in this.listCDataElems)
{
if (name is string)
{
XmlQualifiedName qname = new XmlQualifiedName(name as string, "");
this.lookupCDataElems[qname] = qname;
}
else
{
Debug.Assert(name is XmlQualifiedName);
this.lookupCDataElems[name] = name;
}
}
this.bitsCData.PushBit(false);
}
}
else if (settings.OutputMethod == XmlOutputMethod.Html)
{
// Html output method should output doc-type-decl if system ID or public ID is defined
if (this.systemId != null || this.publicId != null)
{
this.outputDocType = true;
}
}
}
internal async Task WriteDeclAsync(XmlWriter writer, XmlRawWriter rawWriter) {
Debug.Assert(kind == NamespaceKind.NeedToWrite);
if (null != rawWriter) {
await rawWriter.WriteNamespaceDeclarationAsync(prefix, namespaceUri).ConfigureAwait(false);
}
else {
if (prefix.Length == 0) {
await writer.WriteStartAttributeAsync(string.Empty, "xmlns", XmlReservedNs.NsXmlNs).ConfigureAwait(false);
}
else {
await writer.WriteStartAttributeAsync("xmlns", prefix, XmlReservedNs.NsXmlNs).ConfigureAwait(false);
}
await writer.WriteStringAsync(namespaceUri).ConfigureAwait(false);
await writer.WriteEndAttributeAsync().ConfigureAwait(false);
}
}
public QueryOutputWriter(XmlRawWriter writer, XmlWriterSettings settings)
{
_wrapped = writer;
_systemId = settings.DocTypeSystem;
_publicId = settings.DocTypePublic;
if (settings.OutputMethod == XmlOutputMethod.Xml)
{
// Xml output method shouldn't output doc-type-decl if system ID is not defined (even if public ID is)
// Only check for well-formed document if output method is xml
if (_systemId != null)
{
_outputDocType = true;
_checkWellFormedDoc = true;
}
// Check for well-formed document if standalone="yes" in an auto-generated xml declaration
if (settings.AutoXmlDeclaration && settings.Standalone == XmlStandalone.Yes)
{
_checkWellFormedDoc = true;
}
if (settings.CDataSectionElements.Count > 0)
{
_bitsCData = new BitStack();
_lookupCDataElems = new Dictionary <XmlQualifiedName, int>();
_qnameCData = new XmlQualifiedName();
// Add each element name to the lookup table
foreach (XmlQualifiedName name in settings.CDataSectionElements)
{
_lookupCDataElems[name] = 0;
}
_bitsCData.PushBit(false);
}
}
else if (settings.OutputMethod == XmlOutputMethod.Html)
{
// Html output method should output doc-type-decl if system ID or public ID is defined
if (_systemId != null || _publicId != null)
{
_outputDocType = true;
}
}
}
public QueryOutputWriter(XmlRawWriter writer, XmlWriterSettings settings) {
this.wrapped = writer;
this.systemId = settings.DocTypeSystem;
this.publicId = settings.DocTypePublic;
if (settings.OutputMethod == XmlOutputMethod.Xml) {
// Xml output method shouldn't output doc-type-decl if system ID is not defined (even if public ID is)
// Only check for well-formed document if output method is xml
if (this.systemId != null) {
this.outputDocType = true;
this.checkWellFormedDoc = true;
}
// Check for well-formed document if standalone="yes" in an auto-generated xml declaration
if (settings.AutoXmlDeclaration && settings.Standalone == XmlStandalone.Yes)
this.checkWellFormedDoc = true;
this.listCDataElems = settings.CDataSectionElements;
if (this.listCDataElems != null) {
this.bitsCData = new BitStack();
this.lookupCDataElems = new Hashtable();
this.qnameCData = new XmlQualifiedName();
// Add each element name to the lookup table
foreach (object name in this.listCDataElems) {
if (name is string) {
XmlQualifiedName qname = new XmlQualifiedName(name as string, "");
this.lookupCDataElems[qname] = qname;
}
else {
Debug.Assert(name is XmlQualifiedName);
this.lookupCDataElems[name] = name;
}
}
this.bitsCData.PushBit(false);
}
}
else if (settings.OutputMethod == XmlOutputMethod.Html) {
// Html output method should output doc-type-decl if system ID or public ID is defined
if (this.systemId != null || this.publicId != null)
this.outputDocType = true;
}
}
public QueryOutputWriter(XmlRawWriter writer, XmlWriterSettings settings)
{
_wrapped = writer;
_systemId = settings.DocTypeSystem;
_publicId = settings.DocTypePublic;
if (settings.OutputMethod == XmlOutputMethod.Xml)
{
// Xml output method shouldn't output doc-type-decl if system ID is not defined (even if public ID is)
// Only check for well-formed document if output method is xml
if (_systemId != null)
{
_outputDocType = true;
_checkWellFormedDoc = true;
}
// Check for well-formed document if standalone="yes" in an auto-generated xml declaration
if (settings.AutoXmlDeclaration && settings.Standalone == XmlStandalone.Yes)
_checkWellFormedDoc = true;
if (settings.CDataSectionElements.Count > 0)
{
_bitsCData = new BitStack();
_lookupCDataElems = new Dictionary<XmlQualifiedName, int>();
_qnameCData = new XmlQualifiedName();
// Add each element name to the lookup table
foreach (XmlQualifiedName name in settings.CDataSectionElements)
{
_lookupCDataElems[name] = 0;
}
_bitsCData.PushBit(false);
}
}
else if (settings.OutputMethod == XmlOutputMethod.Html)
{
// Html output method should output doc-type-decl if system ID or public ID is defined
if (_systemId != null || _publicId != null)
_outputDocType = true;
}
}
internal void WriteDecl(XmlWriter writer, XmlRawWriter rawWriter)
{
Debug.Assert(kind == NamespaceKind.NeedToWrite);
if (null != rawWriter)
{
rawWriter.WriteNamespaceDeclaration(prefix, namespaceUri);
}
else
{
if (prefix.Length == 0)
{
writer.WriteStartAttribute(string.Empty, "xmlns", XmlReservedNs.NsXmlNs);
}
else
{
writer.WriteStartAttribute("xmlns", prefix, XmlReservedNs.NsXmlNs);
}
writer.WriteString(namespaceUri);
writer.WriteEndAttribute();
}
}
internal async Task WriteDeclAsync(XmlWriter writer, XmlRawWriter rawWriter)
{
Debug.Assert(kind == NamespaceKind.NeedToWrite);
if (null != rawWriter)
{
await rawWriter.WriteNamespaceDeclarationAsync(prefix, namespaceUri).ConfigureAwait(false);
}
else
{
if (prefix.Length == 0)
{
await writer.WriteStartAttributeAsync(string.Empty, "xmlns", XmlReservedNs.NsXmlNs).ConfigureAwait(false);
}
else
{
await writer.WriteStartAttributeAsync("xmlns", prefix, XmlReservedNs.NsXmlNs).ConfigureAwait(false);
}
await writer.WriteStringAsync(namespaceUri).ConfigureAwait(false);
await writer.WriteEndAttributeAsync().ConfigureAwait(false);
}
}
private void CreateWrappedWriter(XmlOutputMethod outMethod)
{
this.writerSettings.ReadOnly = false;
this.writerSettings.OutputMethod = outMethod;
if ((outMethod == XmlOutputMethod.Html) && (this.writerSettings.IndentInternal == TriState.Unknown))
{
this.writerSettings.Indent = true;
}
this.writerSettings.ReadOnly = true;
if (this.textWriter != null)
{
this.wrapped = ((XmlWellFormedWriter)XmlWriter.Create(this.textWriter, this.writerSettings)).RawWriter;
}
else
{
this.wrapped = ((XmlWellFormedWriter)XmlWriter.Create(this.strm, this.writerSettings)).RawWriter;
}
this.eventCache.EndEvents();
this.eventCache.EventsToWriter(this.wrapped);
if (this.onRemove != null)
{
this.onRemove(this.wrapped);
}
}
private void CreateWrappedWriter(XmlOutputMethod outMethod)
{
this.writerSettings.ReadOnly = false;
this.writerSettings.OutputMethod = outMethod;
if ((outMethod == XmlOutputMethod.Html) && (this.writerSettings.IndentInternal == TriState.Unknown))
{
this.writerSettings.Indent = true;
}
this.writerSettings.ReadOnly = true;
if (this.textWriter != null)
{
this.wrapped = ((XmlWellFormedWriter) XmlWriter.Create(this.textWriter, this.writerSettings)).RawWriter;
}
else
{
this.wrapped = ((XmlWellFormedWriter) XmlWriter.Create(this.strm, this.writerSettings)).RawWriter;
}
this.eventCache.EndEvents();
this.eventCache.EventsToWriter(this.wrapped);
if (this.onRemove != null)
{
this.onRemove(this.wrapped);
}
}
internal XmlRawWriterBase64Encoder(XmlRawWriter rawWriter)
{
_rawWriter = rawWriter;
}
public void EventsToWriter(XmlWriter writer)
{
if (this.singleText.Count != 0)
{
writer.WriteString(this.singleText.GetResult());
}
else
{
XmlRawWriter writer2 = writer as XmlRawWriter;
for (int i = 0; i < this.pages.Count; i++)
{
XmlEvent[] eventArray = this.pages[i];
for (int j = 0; j < eventArray.Length; j++)
{
byte[] buffer;
switch (eventArray[j].EventType)
{
case XmlEventType.Unknown:
return;
case XmlEventType.DocType:
{
writer.WriteDocType(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3, (string)eventArray[j].Object);
continue;
}
case XmlEventType.StartElem:
{
writer.WriteStartElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.StartAttr:
{
writer.WriteStartAttribute(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.EndAttr:
{
writer.WriteEndAttribute();
continue;
}
case XmlEventType.CData:
{
writer.WriteCData(eventArray[j].String1);
continue;
}
case XmlEventType.Comment:
{
writer.WriteComment(eventArray[j].String1);
continue;
}
case XmlEventType.PI:
{
writer.WriteProcessingInstruction(eventArray[j].String1, eventArray[j].String2);
continue;
}
case XmlEventType.Whitespace:
{
writer.WriteWhitespace(eventArray[j].String1);
continue;
}
case XmlEventType.String:
{
writer.WriteString(eventArray[j].String1);
continue;
}
case XmlEventType.Raw:
{
writer.WriteRaw(eventArray[j].String1);
continue;
}
case XmlEventType.EntRef:
{
writer.WriteEntityRef(eventArray[j].String1);
continue;
}
case XmlEventType.CharEnt:
{
writer.WriteCharEntity((char)eventArray[j].Object);
continue;
}
case XmlEventType.SurrCharEnt:
{
char[] chArray = (char[])eventArray[j].Object;
writer.WriteSurrogateCharEntity(chArray[0], chArray[1]);
continue;
}
case XmlEventType.Base64:
{
buffer = (byte[])eventArray[j].Object;
writer.WriteBase64(buffer, 0, buffer.Length);
continue;
}
case XmlEventType.BinHex:
{
buffer = (byte[])eventArray[j].Object;
writer.WriteBinHex(buffer, 0, buffer.Length);
continue;
}
case XmlEventType.XmlDecl1:
{
if (writer2 != null)
{
writer2.WriteXmlDeclaration((XmlStandalone)eventArray[j].Object);
}
continue;
}
case XmlEventType.XmlDecl2:
{
if (writer2 != null)
{
writer2.WriteXmlDeclaration(eventArray[j].String1);
}
continue;
}
case XmlEventType.StartContent:
{
if (writer2 != null)
{
writer2.StartElementContent();
}
continue;
}
case XmlEventType.EndElem:
{
if (writer2 == null)
{
break;
}
writer2.WriteEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.FullEndElem:
{
if (writer2 == null)
{
goto Label_0367;
}
writer2.WriteFullEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.Nmsp:
{
if (writer2 == null)
{
goto Label_0394;
}
writer2.WriteNamespaceDeclaration(eventArray[j].String1, eventArray[j].String2);
continue;
}
case XmlEventType.EndBase64:
{
if (writer2 != null)
{
writer2.WriteEndBase64();
}
continue;
}
case XmlEventType.Close:
{
writer.Close();
continue;
}
case XmlEventType.Flush:
{
writer.Flush();
continue;
}
case XmlEventType.Dispose:
{
writer.Dispose();
continue;
}
default:
{
continue;
}
}
writer.WriteEndElement();
continue;
Label_0367:
writer.WriteFullEndElement();
continue;
Label_0394:
writer.WriteAttributeString("xmlns", eventArray[j].String1, "http://www.w3.org/2000/xmlns/", eventArray[j].String2);
}
}
}
}
/// <summary>
/// Constructor.
/// </summary>
public XmlMergeSequenceWriter(XmlRawWriter xwrt) {
this.xwrt = xwrt;
this.lastItemWasAtomic = false;
}
/// <summary>
/// Before calling XmlRawWriter.WriteStartElement(), perform various checks to ensure well-formedness.
/// </summary>
public override void WriteStartElement(string prefix, string localName, string ns) {
Debug.Assert(prefix != null && localName != null && localName.Length != 0 && ns != null, "Invalid argument");
Debug.Assert(ValidateNames.ValidateName(prefix, localName, ns, XPathNodeType.Element, ValidateNames.Flags.All), "Name validation failed");
// Xml state transitions
ConstructWithinContent(XPathNodeType.Element);
// Call XmlRawWriter.WriteStartElement
WriteStartElementUnchecked(prefix, localName, ns);
// Ensure that element's namespace declaration is declared
WriteNamespaceDeclarationUnchecked(prefix, ns);
// Cache attributes in order to detect duplicates
if (this.attrCache == null)
this.attrCache = new XmlAttributeCache();
this.attrCache.Init(Writer);
Writer = this.attrCache;
this.attrCache = null;
// Push element names onto a stack
PushElementNames(prefix, localName, ns);
}
//
// Constructor & finalizer
//
internal XmlWellFormedWriter(XmlWriter writer, XmlWriterSettings settings) {
Debug.Assert(writer != null);
Debug.Assert(settings != null);
Debug.Assert(MaxNamespacesWalkCount <= 3);
this.writer = writer;
rawWriter = writer as XmlRawWriter;
predefinedNamespaces = writer as IXmlNamespaceResolver;
if (rawWriter != null) {
rawWriter.NamespaceResolver = new NamespaceResolverProxy(this);
}
checkCharacters = settings.CheckCharacters;
conformanceLevel = settings.ConformanceLevel;
stateTable = (conformanceLevel == ConformanceLevel.Document) ? StateTableDocument : StateTableAuto;
currentState = State.Start;
nsStack = new Namespace[NamespaceStackInitialSize];
nsStack[0].Set("xmlns", XmlReservedNs.NsXmlNs, NamespaceKind.Special);
nsStack[1].Set("xml", XmlReservedNs.NsXml, NamespaceKind.Special);
if (predefinedNamespaces == null) {
nsStack[2].Set(string.Empty, string.Empty, NamespaceKind.Implied);
}
else {
string defaultNs = predefinedNamespaces.LookupNamespace(string.Empty);
nsStack[2].Set(string.Empty, (defaultNs == null ? string.Empty : defaultNs), NamespaceKind.Implied);
}
nsTop = 2;
elemScopeStack = new ElementScope[ElementStackInitialSize];
elemScopeStack[0].Set(string.Empty, string.Empty, string.Empty, nsTop);
elemScopeStack[0].xmlSpace = XmlSpace.None;
elemScopeStack[0].xmlLang = null;
elemTop = 0;
attrStack = new AttrName[AttributeArrayInitialSize];
attrValue = new StringBuilder();
hasher = new SecureStringHasher();
}
//
// Constructor & finalizer
//
internal XmlWellFormedWriter(XmlWriter writer, XmlWriterSettings settings)
{
Debug.Assert(writer != null);
Debug.Assert(settings != null);
Debug.Assert(MaxNamespacesWalkCount <= 3);
_writer = writer;
_rawWriter = writer as XmlRawWriter;
_predefinedNamespaces = writer as IXmlNamespaceResolver;
if (_rawWriter != null)
{
_rawWriter.NamespaceResolver = new NamespaceResolverProxy(this);
}
_checkCharacters = settings.CheckCharacters;
_omitDuplNamespaces = (settings.NamespaceHandling & NamespaceHandling.OmitDuplicates) != 0;
_writeEndDocumentOnClose = settings.WriteEndDocumentOnClose;
_conformanceLevel = settings.ConformanceLevel;
_stateTable = (_conformanceLevel == ConformanceLevel.Document) ? s_stateTableDocument : s_stateTableAuto;
_currentState = State.Start;
_nsStack = new Namespace[NamespaceStackInitialSize];
_nsStack[0].Set("xmlns", XmlReservedNs.NsXmlNs, NamespaceKind.Special);
_nsStack[1].Set("xml", XmlReservedNs.NsXml, NamespaceKind.Special);
if (_predefinedNamespaces == null)
{
_nsStack[2].Set(string.Empty, string.Empty, NamespaceKind.Implied);
}
else
{
string defaultNs = _predefinedNamespaces.LookupNamespace(string.Empty);
_nsStack[2].Set(string.Empty, (defaultNs == null ? string.Empty : defaultNs), NamespaceKind.Implied);
}
_nsTop = 2;
_elemScopeStack = new ElementScope[ElementStackInitialSize];
_elemScopeStack[0].Set(string.Empty, string.Empty, string.Empty, _nsTop);
_elemScopeStack[0].xmlSpace = XmlSpace.None;
_elemScopeStack[0].xmlLang = null;
_elemTop = 0;
_attrStack = new AttrName[AttributeArrayInitialSize];
_hasher = new SecureStringHasher();
}
internal Task WriteFullEndElementAsync(XmlRawWriter rawWriter)
{
return rawWriter.WriteFullEndElementAsync(prefix, localName, namespaceUri);
}
internal void WriteFullEndElement(XmlRawWriter rawWriter)
{
rawWriter.WriteFullEndElement(this.prefix, this.localName, this.namespaceUri);
}
internal void WriteDecl(XmlWriter writer, XmlRawWriter rawWriter)
{
Debug.Assert(kind == NamespaceKind.NeedToWrite);
if (null != rawWriter)
{
rawWriter.WriteNamespaceDeclaration(prefix, namespaceUri);
}
else
{
if (prefix.Length == 0)
{
writer.WriteStartAttribute(string.Empty, XmlConst.NsXmlNs, XmlConst.ReservedNsXmlNs);
}
else
{
writer.WriteStartAttribute(XmlConst.NsXmlNs, prefix, XmlConst.ReservedNsXmlNs);
}
writer.WriteString(namespaceUri);
writer.WriteEndAttribute();
}
}
/// <summary>
/// Constructor.
/// </summary>
public XmlMergeSequenceWriter(XmlRawWriter xwrt)
{
_xwrt = xwrt;
_lastItemWasAtomic = false;
}
internal void WriteDecl(XmlWriter writer, XmlRawWriter rawWriter)
{
if (rawWriter != null)
{
rawWriter.WriteNamespaceDeclaration(this.prefix, this.namespaceUri);
}
else
{
if (this.prefix.Length == 0)
{
writer.WriteStartAttribute(string.Empty, "xmlns", "http://www.w3.org/2000/xmlns/");
}
else
{
writer.WriteStartAttribute("xmlns", this.prefix, "http://www.w3.org/2000/xmlns/");
}
writer.WriteString(this.namespaceUri);
writer.WriteEndAttribute();
}
}
/// <summary>
/// Create either the Html or Xml writer and send any cached events to it.
/// </summary>
private void CreateWrappedWriter(XmlOutputMethod outMethod) {
Debug.Assert(this.wrapped == null);
// Create either the Xml or Html writer
this.writerSettings.ReadOnly = false;
this.writerSettings.OutputMethod = outMethod;
// If Indent was not set by the user, then default to True for Html
if (outMethod == XmlOutputMethod.Html && this.writerSettings.IndentInternal == TriState.Unknown)
this.writerSettings.Indent = true;
this.writerSettings.ReadOnly = true;
if (textWriter != null)
this.wrapped = ((XmlWellFormedWriter)XmlWriter.Create(this.textWriter, this.writerSettings)).RawWriter;
else
this.wrapped = ((XmlWellFormedWriter)XmlWriter.Create(this.strm, this.writerSettings)).RawWriter;
// Send cached events to the new writer
this.eventCache.EndEvents();
this.eventCache.EventsToWriter(this.wrapped);
// Send OnRemoveWriter event
if (this.onRemove != null)
(this.onRemove)(this.wrapped);
}
internal XmlRawWriterBase64Encoder( XmlRawWriter rawWriter ) {
this.rawWriter = rawWriter;
}
internal void WriteFullEndElement(XmlRawWriter rawWriter)
{
rawWriter.WriteFullEndElement(prefix, localName, namespaceUri);
}
/// <summary>
/// This method will be called if "xwrt" is a writer which no longer needs to be part of the pipeline and
/// wishes to replace itself with a different writer. For example, the auto-detect writer replaces itself
/// with the Html or Xml writer once it has determined which output mode to use.
/// </summary>
private void SetWrappedWriter(XmlRawWriter writer) {
// Reuse XmlAttributeCache so that it doesn't have to be recreated every time
if (Writer is XmlAttributeCache)
this.attrCache = (XmlAttributeCache) Writer;
Writer = writer;
}
internal void WriteFullEndElement(XmlRawWriter rawWriter)
{
rawWriter.WriteFullEndElement(prefix, localName, namespaceUri);
}
internal Task WriteFullEndElementAsync(XmlRawWriter rawWriter)
{
return(rawWriter.WriteFullEndElementAsync(prefix, localName, namespaceUri));
}
internal NavigatorOutput(string baseUri) {
doc = new XPathDocument();
this.wr = doc.LoadFromWriter(XPathDocument.LoadFlags.AtomizeNames, baseUri);
}
internal XmlWellFormedWriter(XmlWriter writer, XmlWriterSettings settings)
{
this.writer = writer;
this.rawWriter = writer as XmlRawWriter;
this.predefinedNamespaces = writer as IXmlNamespaceResolver;
if (this.rawWriter != null)
{
this.rawWriter.NamespaceResolver = new NamespaceResolverProxy(this);
}
this.checkCharacters = settings.CheckCharacters;
this.omitDuplNamespaces = (settings.NamespaceHandling & NamespaceHandling.OmitDuplicates) != NamespaceHandling.Default;
this.conformanceLevel = settings.ConformanceLevel;
this.stateTable = (this.conformanceLevel == ConformanceLevel.Document) ? StateTableDocument : StateTableAuto;
this.currentState = State.Start;
this.nsStack = new Namespace[8];
this.nsStack[0].Set("xmlns", "http://www.w3.org/2000/xmlns/", NamespaceKind.Special);
this.nsStack[1].Set("xml", "http://www.w3.org/XML/1998/namespace", NamespaceKind.Special);
if (this.predefinedNamespaces == null)
{
this.nsStack[2].Set(string.Empty, string.Empty, NamespaceKind.Implied);
}
else
{
string str = this.predefinedNamespaces.LookupNamespace(string.Empty);
this.nsStack[2].Set(string.Empty, (str == null) ? string.Empty : str, NamespaceKind.Implied);
}
this.nsTop = 2;
this.elemScopeStack = new ElementScope[8];
this.elemScopeStack[0].Set(string.Empty, string.Empty, string.Empty, this.nsTop);
this.elemScopeStack[0].xmlSpace = System.Xml.XmlSpace.None;
this.elemScopeStack[0].xmlLang = null;
this.elemTop = 0;
this.attrStack = new AttrName[8];
this.hasher = new SecureStringHasher();
}
