|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Schema;
namespace System.Xml
{
//
// XmlCharCheckingWriter
//
internal sealed partial class XmlCharCheckingWriter : XmlWrappingWriter
{
public override Task WriteDocTypeAsync(string name, string? pubid, string? sysid, string? subset)
{
if (_checkNames)
{
ValidateQName(name);
}
if (_checkValues)
{
if (pubid != null)
{
int i;
if ((i = XmlCharType.IsPublicId(pubid)) >= 0)
{
throw XmlConvert.CreateInvalidCharException(pubid, i);
}
}
if (sysid != null)
{
CheckCharacters(sysid);
}
if (subset != null)
{
CheckCharacters(subset);
}
}
if (_replaceNewLines)
{
sysid = ReplaceNewLines(sysid);
pubid = ReplaceNewLines(pubid);
subset = ReplaceNewLines(subset);
}
return writer.WriteDocTypeAsync(name, pubid, sysid, subset);
}
public override Task WriteStartElementAsync(string? prefix, string localName, string? ns)
{
if (_checkNames)
{
ArgumentException.ThrowIfNullOrEmpty(localName);
ValidateNCName(localName);
if (prefix != null && prefix.Length > 0)
{
ValidateNCName(prefix);
}
}
return writer.WriteStartElementAsync(prefix, localName, ns);
}
protected internal override Task WriteStartAttributeAsync(string? prefix, string localName, string? ns)
{
if (_checkNames)
{
ArgumentException.ThrowIfNullOrEmpty(localName);
ValidateNCName(localName);
if (prefix != null && prefix.Length > 0)
{
ValidateNCName(prefix);
}
}
return writer.WriteStartAttributeAsync(prefix, localName, ns);
}
public override async Task WriteCDataAsync(string? text)
{
if (text != null)
{
if (_checkValues)
{
CheckCharacters(text);
}
if (_replaceNewLines)
{
text = ReplaceNewLines(text);
}
int i;
while ((i = text.IndexOf("]]>", StringComparison.Ordinal)) >= 0)
{
await writer.WriteCDataAsync(text.Substring(0, i + 2)).ConfigureAwait(false);
text = text.Substring(i + 2);
}
}
await writer.WriteCDataAsync(text).ConfigureAwait(false);
}
public override Task WriteCommentAsync(string? text)
{
if (text != null)
{
if (_checkValues)
{
CheckCharacters(text);
text = InterleaveInvalidChars(text, '-', '-');
}
if (_replaceNewLines)
{
text = ReplaceNewLines(text);
}
}
return writer.WriteCommentAsync(text);
}
public override Task WriteProcessingInstructionAsync(string name, string? text)
{
if (_checkNames)
{
ValidateNCName(name);
}
if (text != null)
{
if (_checkValues)
{
CheckCharacters(text);
text = InterleaveInvalidChars(text, '?', '>');
}
if (_replaceNewLines)
{
text = ReplaceNewLines(text);
}
}
return writer.WriteProcessingInstructionAsync(name, text!);
}
public override Task WriteEntityRefAsync(string name)
{
if (_checkNames)
{
ValidateQName(name);
}
return writer.WriteEntityRefAsync(name);
}
public override Task WriteWhitespaceAsync(string? ws)
{
ws ??= string.Empty;
// "checkNames" is intentional here; if false, the whitespace is checked in XmlWellformedWriter
if (_checkNames)
{
int i;
if ((i = XmlCharType.IsOnlyWhitespaceWithPos(ws)) != -1)
{
throw new ArgumentException(SR.Format(SR.Xml_InvalidWhitespaceCharacter, XmlException.BuildCharExceptionArgs(ws, i)));
}
}
if (_replaceNewLines)
{
ws = ReplaceNewLines(ws);
}
return writer.WriteWhitespaceAsync(ws);
}
public override Task WriteStringAsync(string? text)
{
if (text != null)
{
if (_checkValues)
{
CheckCharacters(text);
}
if (_replaceNewLines && WriteState != WriteState.Attribute)
{
text = ReplaceNewLines(text);
}
}
return writer.WriteStringAsync(text);
}
public override Task WriteSurrogateCharEntityAsync(char lowChar, char highChar)
{
return writer.WriteSurrogateCharEntityAsync(lowChar, highChar);
}
public override Task WriteCharsAsync(char[] buffer, int index, int count)
{
ArgumentNullException.ThrowIfNull(buffer);
ArgumentOutOfRangeException.ThrowIfNegative(index);
ArgumentOutOfRangeException.ThrowIfNegative(count);
ArgumentOutOfRangeException.ThrowIfGreaterThan(count, buffer.Length - index);
if (_checkValues)
{
CheckCharacters(buffer, index, count);
}
if (_replaceNewLines && WriteState != WriteState.Attribute)
{
string? text = ReplaceNewLines(buffer, index, count);
if (text != null)
{
return WriteStringAsync(text);
}
}
return writer.WriteCharsAsync(buffer, index, count);
}
public override Task WriteNmTokenAsync(string name)
{
if (_checkNames)
{
ArgumentException.ThrowIfNullOrEmpty(name);
XmlConvert.VerifyNMTOKEN(name);
}
return writer.WriteNmTokenAsync(name);
}
public override Task WriteNameAsync(string name)
{
if (_checkNames)
{
XmlConvert.VerifyQName(name, ExceptionType.XmlException);
}
return writer.WriteNameAsync(name);
}
public override Task WriteQualifiedNameAsync(string localName, string? ns)
{
if (_checkNames)
{
ValidateNCName(localName);
}
return writer.WriteQualifiedNameAsync(localName, ns);
}
}
}
|