|
public WriteNode ( |
||
| navigator | ||
| defattr | bool | |
| return | void | |
public void WriteXml(XmlWriter xmlWriter)
{
if (wsdl != null)
{
using (MemoryStream ms = new MemoryStream())
{
wsdl.Write(ms);
XmlDictionaryReaderQuotas quota = new XmlDictionaryReaderQuotas();
quota.MaxDepth = 32;
quota.MaxStringContentLength = 8192;
quota.MaxArrayLength = 16384;
quota.MaxBytesPerRead = 4096;
quota.MaxNameTableCharCount = 16384;
ms.Seek(0, SeekOrigin.Begin);
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(ms, null, quota, null);
if ((reader.MoveToContent() == XmlNodeType.Element) && (reader.Name == "wsdl:definitions"))
{
xmlWriter.WriteNode(reader, false);
}
reader.Close();
}
}
}
/// <summary>
/// Useful for writing the debug XML of a child component to its parent
/// component's debug XML stream.
/// </summary>
protected void WriteDebugXmlNode(XmlReader reader)
{
if (_xmlDebugging)
{
_debugXmlWriter.WriteNode(reader, false);
}
}
public void fillXml(XmlWriter xw)
{
using (XmlReader xr = XmlReader.Create(new StringReader(this.xmls)))
{
xr.ReadToFollowing(_xml_tag);
xw.WriteNode(xr, false);
}
}
public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("index", index.ToString());
if (template != null)
{
writer.WriteStartElement("template");
writer.WriteNode(template.CreateReader(), true);
writer.WriteEndElement();
}
}
protected override void CopyNode(XmlReader reader, XmlWriter writer)
{
if (reader.NodeType == XmlNodeType.Element && reader.Name == "configuration")
{
writer.WriteStartElement("configuration");
writer.WriteAttributeString("version", "2");
reader.Read();
} else
{
writer.WriteNode(reader, true);
}
}
/// <summary>
/// Extract message from soap
/// </summary>
/// <param name="input">
/// The input
/// </param>
/// <param name="writer">
/// The writer
/// </param>
public static void ExtractSdmxMessage(Stream input, XmlWriter writer)
{
using (var reader = XmlReader.Create(input))
{
SdmxMessageUtil.FindSdmx(reader);
if (reader.EOF)
{
return;
}
writer.WriteStartDocument();
writer.WriteNode(reader, false);
}
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("Title", this.Title);
writer.WriteAttributeString("Row", this.Row.ToString());
writer.WriteAttributeString("Column", this.Column.ToString());
writer.WriteStartElement(XMLConstants.PROVISIONING_SCHEMA_PREFIX, "Contents", XMLConstants.PROVISIONING_SCHEMA_NAMESPACE_2015_12);
using (XmlReader xr = new XmlNodeReader(this.Contents))
{
writer.WriteNode(xr, false);
}
writer.WriteEndElement();
}
public override void WriteTo(XmlWriter writer)
{
XmlReader r;
lock (this)
{
if (_reader == null) throw new Exception("The XmlReader has already been opened once and cannot be reset.");
r = _reader;
_reader = null;
}
if (r.ReadState == ReadState.Initial)
r.Read();
while (!r.EOF)
writer.WriteNode(r, true);
}
//public CustomSaml2SecurityTokenHandler(SecurityTokenHandlerConfiguration configuration)
//{
// SecurityTokenHandlerConfiguration handlerConfig = configuration ?? new SecurityTokenHandlerConfiguration
// {
// AudienceRestriction = {AudienceMode = AudienceUriMode.Never},
// CertificateValidationMode = X509CertificateValidationMode.None,
// RevocationMode = X509RevocationMode.NoCheck,
// MaxClockSkew = new TimeSpan(50000000),
// CertificateValidator = X509CertificateValidator.None
// };
// Configuration = handlerConfig;
//}
//public CustomSaml2SecurityTokenHandler()
// : this(null)
//{
//}
protected override void WriteAttributeValue(XmlWriter writer, string value, Saml2Attribute attribute)
{
var sb = new StringBuilder("<a>");
sb.Append(value);
sb.Append("</a>");
byte[] rawValue = new UTF8Encoding().GetBytes(sb.ToString());
using (
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(rawValue,
XmlDictionaryReaderQuotas.Max))
{
reader.ReadStartElement("a");
while (reader.NodeType != XmlNodeType.EndElement ||
(reader.NodeType == XmlNodeType.EndElement && reader.Name != "a"))
{
writer.WriteNode(reader, false);
}
reader.ReadEndElement();
reader.Close();
}
}
protected override bool SerializeToXmlElement(XmlWriter writer, String elementName)
{
bool dataToWrite = this.XmlElement != null;
if (dataToWrite && writer != null)
{
if (!String.Equals(elementName, ConfigurationStrings.XmlElement, StringComparison.Ordinal))
{
writer.WriteStartElement(elementName);
}
using (XmlNodeReader reader = new XmlNodeReader(this.XmlElement))
{
writer.WriteNode(reader, false);
}
if (!String.Equals(elementName, ConfigurationStrings.XmlElement, StringComparison.Ordinal))
{
writer.WriteEndElement();
}
}
return dataToWrite;
}
private bool SignForm(XmlReader reader, XmlWriter writer)
{
if (!reader.IsStartElement("model"))
{
return false;
}
var doc = XDocument.Load(reader.ReadSubtree());
var formContents = GetFormContents(doc);
var submission = GetSubmission(doc);
if (submission != null)
{
submission.Element.SetAttributeValue("resource", submission.TargetUri.Replace(signaturePlaceholder, signature.GenerateSignature(formContents)));
}
reader.ReadEndElement();
writer.WriteNode(doc.CreateReader(), false);
writer.Flush();
return true;
}
public void WriteXml(XmlWriter xmlWriter)
{
if (this.wsdl != null)
{
using (MemoryStream stream = new MemoryStream())
{
this.wsdl.Write(stream);
XmlDictionaryReaderQuotas quotas = new XmlDictionaryReaderQuotas {
MaxDepth = 0x20,
MaxStringContentLength = 0x2000,
MaxArrayLength = 0x4000,
MaxBytesPerRead = 0x1000,
MaxNameTableCharCount = 0x4000
};
stream.Seek(0L, SeekOrigin.Begin);
XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(stream, null, quotas, null);
if ((reader.MoveToContent() == XmlNodeType.Element) && (reader.Name == "wsdl:definitions"))
{
xmlWriter.WriteNode(reader, false);
}
reader.Close();
}
}
}
/// <summary>
/// See <see cref="IXmlSerializable.WriteXml"/>.
/// </summary>
public void WriteXml(XmlWriter writer)
{
writer.WriteNode(this, false);
}
public override void WriteNode(XmlReader reader, bool defattr)
{
CheckAsync();
_coreWriter.WriteNode(reader, defattr);
}
private void InvokeMethod(XmlWriter w, string methodName)
{
byte[] buffer = new byte[10];
switch (methodName)
{
case "WriteStartDocument":
w.WriteStartDocument();
break;
case "WriteStartElement":
w.WriteStartElement("root");
break;
case "WriteEndElement":
w.WriteEndElement();
break;
case "WriteStartAttribute":
w.WriteStartAttribute("attr");
break;
case "WriteEndAttribute":
w.WriteEndAttribute();
break;
case "WriteCData":
w.WriteCData("test");
break;
case "WriteComment":
w.WriteComment("test");
break;
case "WritePI":
w.WriteProcessingInstruction("name", "test");
break;
case "WriteEntityRef":
w.WriteEntityRef("e");
break;
case "WriteCharEntity":
w.WriteCharEntity('c');
break;
case "WriteSurrogateCharEntity":
w.WriteSurrogateCharEntity('\uDC00', '\uDBFF');
break;
case "WriteWhitespace":
w.WriteWhitespace(" ");
break;
case "WriteString":
w.WriteString("foo");
break;
case "WriteChars":
char[] charArray = new char[] { 'a', 'b', 'c', 'd' };
w.WriteChars(charArray, 0, 3);
break;
case "WriteRaw":
w.WriteRaw("<foo>bar</foo>");
break;
case "WriteBase64":
w.WriteBase64(buffer, 0, 9);
break;
case "WriteBinHex":
w.WriteBinHex(buffer, 0, 9);
break;
case "LookupPrefix":
string str = w.LookupPrefix("foo");
break;
case "WriteNmToken":
w.WriteNmToken("foo");
break;
case "WriteName":
w.WriteName("foo");
break;
case "WriteQualifiedName":
w.WriteQualifiedName("foo", "bar");
break;
case "WriteValue":
w.WriteValue(Int32.MaxValue);
break;
case "WriteAttributes":
XmlReader xr1 = ReaderHelper.Create(new StringReader("<root attr='test'/>"));
xr1.Read();
w.WriteAttributes(xr1, false);
break;
case "WriteNodeReader":
XmlReader xr2 = ReaderHelper.Create(new StringReader("<root/>"));
xr2.Read();
w.WriteNode(xr2, false);
break;
case "Flush":
w.Flush();
break;
default:
CError.Equals(false, "Unexpected param in testcase: {0}", methodName);
break;
}
}
private static void ProcessHeaderNodeHACK(XmlWriter writer, XmlNode alphaDom, XmlNode betaDom)
{
// Without a principled merge system for the header element,
// just pick the longest one from alpha/beta.
// NB: This has *no* tests, since it is such a hack.
var alphaHeader = alphaDom.SelectSingleNode("lift/header");
var betaHeader = betaDom.SelectSingleNode("lift/header");
XmlNode winningHeader;
if (alphaHeader == null && betaHeader == null)
winningHeader = null;
else if (alphaHeader == null & betaHeader != null)
winningHeader = betaHeader;
else if (betaHeader == null)
winningHeader = alphaHeader;
else if (alphaHeader.ChildNodes.Count > betaHeader.ChildNodes.Count)
winningHeader = alphaHeader;
else
winningHeader = betaHeader;
if (winningHeader != null)
writer.WriteNode(winningHeader.CreateNavigator(), false);
}
/// <summary>
/// Read an object.
/// </summary>
private void ReadObject(AmfContext context, AmfStreamReader reader, XmlWriter output = null)
{
var reference = reader.PeekChar();
int index;
if ((reference & 0x1) == 0 && ReadReference(context, reader, out index, out reference))
{
if (output != null) WriteReference(index, output);
return;
}
context.References.Track();
int traitsindex, traitsreference;
AmfTypeTraits traits;
#region Read object's traits
if ((traits = ReadTraitsReference(context, reader, out traitsindex, out traitsreference)) == null)
{
var isExternalizable = ((traitsreference & 0x4) == 4);
var isDynamic = ((traitsreference & 0x8) == 8);
var typeName = ReadString(context, reader);
var count = (traitsreference >> 4);
var classMembers = new string[count];
for (var i = 0; i < count; i++)
classMembers[i] = ReadString(context, reader);
traits = new AmfTypeTraits
{
IsDynamic = isDynamic,
IsExternalizable = isExternalizable,
TypeName = typeName,
//No property names are included for types
//that are externizable or dynamic
ClassMembers = isDynamic || isExternalizable
? new string[0]
: classMembers
};
context.TraitsReferences.Add(traits);
}
#endregion
#if DEBUG
Debug.WriteLine(string.Format(Errors.Amf3Decoder_ReadObject_Debug_Name, traits.TypeName));
if (traits.IsDynamic)
Debug.WriteLine(Errors.Amf3Decoder_ReadObject_Debug_Dynamic);
else if (traits.IsExternalizable)
Debug.WriteLine(Errors.Amf3Decoder_ReadObject_Debug_Externizable);
else
Debug.WriteLine(string.Format(Errors.Amf3Decoder_ReadObject_Debug_Members, traits.ClassMembers.Length));
#endif
using (var ms = new MemoryStream())
{
#region Reading object members
var members = new List<string>();
var settings = new XmlWriterSettings
{
};
var buffer = XmlWriter.Create(ms, settings);
buffer.WriteStartDocument();
buffer.WriteStartElement("buffer", AmfxContent.Namespace);
#if DEBUG
var memberPosition = 0;
#endif
//Read object's properties
foreach (var classMember in traits.ClassMembers)
{
#if DEBUG
Debug.WriteLine(string.Format(Errors.Amf3Decoder_ReadObject_Debug_ReadingField, memberPosition,
classMember));
memberPosition++;
#endif
ReadAmfValue(context, reader, buffer);
members.Add(classMember);
}
//Read dynamic properties too
if (traits.IsDynamic)
{
#if DEBUG
Debug.WriteLine(Errors.Amf3Decoder_ReadObject_Debug_ReadingDynamic);
#endif
var key = ReadString(context, reader);
while (key != string.Empty)
{
#if DEBUG
Debug.WriteLine(string.Format(Errors.Amf3Decoder_ReadObject_Debug_ReadingDynamicField, key));
#endif
ReadAmfValue(context, reader, buffer);
members.Add(key);
key = ReadString(context, reader);
}
#if DEBUG
Debug.WriteLine(Errors.Amf3Decoder_ReadObject_Debug_DynamicEnd);
#endif
}
buffer.WriteEndElement();
buffer.WriteEndDocument();
buffer.Flush();
#endregion
#if DEBUG
Debug.WriteLine(Errors.Amf3Decoder_ReadObject_Debug_End);
#endif
#region Writing member values
if (output != null)
{
output.WriteStartElement(AmfxContent.Object);
if (traits.TypeName != AmfTypeTraits.BaseTypeAlias)
output.WriteAttributeString(AmfxContent.ObjectType, traits.TypeName);
output.WriteStartElement(AmfxContent.Traits);
//Regular traits object
//Always write traits for dynamic objects
if (traitsindex == -1 || traits.IsDynamic)
{
if (traits.IsExternalizable)
{
output.WriteAttributeString(AmfxContent.TraitsExternizable, AmfxContent.True);
}
else
{
//Write object members
foreach (var classMember in members)
{
output.WriteStartElement(AmfxContent.String);
output.WriteValue(classMember);
output.WriteEndElement();
}
}
}
//Traits object reference
else
{
output.WriteAttributeString(AmfxContent.TraitsId, traitsindex.ToString());
}
output.WriteEndElement(); //End of traits
//Write object members
if (members.Count > 0)
{
ms.Position = 0;
var bufferreader = XmlReader.Create(ms);
bufferreader.Read();
bufferreader.ReadStartElement();
while (bufferreader.Depth >= 1)
output.WriteNode(bufferreader, false);
}
output.WriteEndElement(); //End of object
}
#endregion
}
}
public virtual void WriteSubtree(XmlWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
writer.WriteNode(this, true);
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
if (this.IsNull)
{
writer.WriteAttributeString("xsi", "nil", "http://www.w3.org/2001/XMLSchema-instance", "true");
}
else
{
XmlReader reader = this.CreateReader();
if (reader.ReadState == ReadState.Initial)
{
reader.Read();
}
while (!reader.EOF)
{
writer.WriteNode(reader, true);
}
}
writer.Flush();
}
public void WriteTo(int sectionIndex, XmlWriter writer)
{
if (_bufferState != BufferState.Reading)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateInvalidStateException());
XmlDictionaryReader reader = GetReader(sectionIndex);
try
{
writer.WriteNode(reader, false);
}
finally
{
reader.Dispose();
}
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
if (IsNull)
{
writer.WriteAttributeString("xsi", "nil", XmlSchema.InstanceNamespace, "true");
}
else
{
// VSTFDevDiv
XmlReader reader = this.CreateReader();
if (reader.ReadState == ReadState.Initial)
reader.Read();
while (!reader.EOF)
{
writer.WriteNode(reader, true);
}
}
writer.Flush();
}
public override void WriteTo(XmlWriter w)
{
w.WriteNode(new XPathNavigatorReader(_navigator), false);
}
public virtual void WriteSubtree(XmlWriter writer)
{
if (null == writer)
throw new ArgumentNullException(nameof(writer));
writer.WriteNode(this, true);
}
public override void WriteTo(XmlWriter w)
{
w.WriteNode(_navigator.ReadSubtree(), false);
}
private void CopyXmlReaderContent(XmlReader reader, XmlWriter writer)
{
using (writer) {
reader.MoveToContent();
Debug.Assert(reader.ReadState == ReadState.Interactive);
while (!reader.EOF) {
writer.WriteNode(reader, false);
}
}
reader.Close();
}
public override void WriteTo(XmlWriter w)
{
w.WriteNode(_reader, _default);
_reader.Close();
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
if (IsNull)
{
writer.WriteAttributeString("xsi", "nil", XmlSchema.InstanceNamespace, "true");
}
else
{
// Instead of the WriteRaw use the WriteNode. As Tds sends a binary stream - Create a XmlReader to convert
// get the Xml string value from the binary and call WriteNode to pass that out to the XmlWriter.
XmlReader reader = CreateReader();
if (reader.ReadState == ReadState.Initial)
reader.Read();
while (!reader.EOF)
{
writer.WriteNode(reader, true);
}
}
writer.Flush();
}
public virtual void WriteTo(XmlWriter writer)
{
using (XmlReader reader = OpenReader())
writer.WriteNode(reader, true);
}
protected override void ProcessXmlReader(XmlReader xmlReader, XmlWriter xmlWriter)
{
try
{
while (!xmlReader.EOF)
{
xmlWriter.WriteNode(xmlReader, false);
}
}
catch (PipelineStoppedException)
{
throw;
}
catch (Exception ex)
{
ErrorHandler.WriteXmlError(ex);
}
}
public override void WriteNode(XmlReader reader, bool defattr)
{
writer.WriteNode(reader, defattr);
}
/// <summary>
/// Called by the runtime when all entities are written and contents needs to flushed to the underlying stream.
/// </summary>
/// <param name="writer">XmlWriter to which this feed will be serialized to</param>
public override void WriteFeed(XmlWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
_document.Add(_root);
// Write the </feed> end element.
writer.WriteNode(_document.CreateReader(), true);
writer.Flush();
}
public virtual void WriteSubtree (XmlWriter writer)
{
writer.WriteNode (this, false);
}
private static void ProcessEntry(XmlWriter writer, IMergeEventListener eventListener, IMergeStrategy mergingStrategy,
XmlNode ancestorDom, HashSet<string> processedIds,
XmlNode sourceEntry, string sourceLabel, string sourcePath,
IDictionary<string, XmlNode> otherIdNodeIndex, string otherLabel, string otherPath)
{
var id = LiftUtils.GetId(sourceEntry);
if (processedIds.Contains(id))
return; // Already handled the id.
XmlNode otherEntry;
var commonEntry = FindEntry(ancestorDom, id);
if (!otherIdNodeIndex.TryGetValue(id, out otherEntry))
{
// It is in source, but not in target, so it clearly has been deleted by target (new style deletion).
if (LiftUtils.GetIsMarkedAsDeleted(sourceEntry))
{
if (!LiftUtils.GetIsMarkedAsDeleted(commonEntry))
{
// source and target both deleted but in different ways, so make deletion change report.
// There is no need to write anything.
eventListener.ChangeOccurred(new XmlDeletionChangeReport(sourcePath, commonEntry, sourceEntry));
}
//else
//{
// // Make it go away without fanfare by doing nothing to writer, since target actually removed the dead entry.
//}
processedIds.Add(id);
return;
}
if (commonEntry == null)
{
// source added it
eventListener.ChangeOccurred(new XmlAdditionChangeReport(sourcePath, sourceEntry));
writer.WriteNode(sourceEntry.CreateNavigator(), false);
}
else
{
if (AreTheSame(sourceEntry, commonEntry))
{
// target's deletion wins with a plain vanilla deletion report.
eventListener.ChangeOccurred(new XmlDeletionChangeReport(sourcePath, commonEntry, otherEntry));
}
else
{
// source wins over target's new style deletion on the least loss priciple.
// Add an edit vs remove conflict report.
eventListener.ConflictOccurred(new RemovedVsEditedElementConflict("entry", sourceEntry, otherEntry, commonEntry, new MergeSituation(sourcePath, sourceLabel, "", otherLabel, "", MergeOrder.ConflictHandlingModeChoices.WeWin), null, sourceLabel));
writer.WriteNode(sourceEntry.CreateNavigator(), false);
}
processedIds.Add(id);
return;
}
}
else if (AreTheSame(sourceEntry, otherEntry))
{
//unchanged or both made same change
writer.WriteNode(sourceEntry.CreateNavigator(), false);
}
else if (LiftUtils.GetIsMarkedAsDeleted(otherEntry))
{
// source edited, target deleted (old style deletion using dateDeleted attr).
eventListener.ConflictOccurred(new RemovedVsEditedElementConflict("entry", sourceEntry, otherEntry, commonEntry, new MergeSituation(sourcePath, sourceLabel, "", otherLabel, "", MergeOrder.ConflictHandlingModeChoices.WeWin), null, sourceLabel));
}
else if (LiftUtils.GetIsMarkedAsDeleted(sourceEntry))
{
// source deleted (old style), but target edited.
// target wins with the least loss principle.
// But generate a conflict report.
eventListener.ConflictOccurred(new RemovedVsEditedElementConflict("entry", otherEntry, sourceEntry, commonEntry, new MergeSituation(otherPath, otherLabel, "", sourceLabel, "", MergeOrder.ConflictHandlingModeChoices.TheyWin), null, sourceLabel));
writer.WriteNode(otherEntry.CreateNavigator(), false);
}
else
{
// One or both of them edited it, so merge the hard way.
using (var reader = XmlReader.Create(new StringReader(
mergingStrategy.MakeMergedEntry(eventListener, sourceEntry, otherEntry, commonEntry)
)))
{
writer.WriteNode(reader, false);
}
}
processedIds.Add(id);
}
