/// <summary>
/// Writes the text value (as a JSON string) as an element of a JSON array.
/// </summary>
/// <param name="value">The value to write.</param>
/// <exception cref="ArgumentException">
/// Thrown when the specified value is too large.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Thrown if this would result in invalid JSON being written (while validation is enabled).
/// </exception>
/// <remarks>
/// The value is escaped before writing.
/// </remarks>
public void WriteStringValue(ReadOnlySpan <char> value)
{
JsonWriterHelper.ValidateValue(value);
WriteStringEscape(value);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
internal void WriteNumber(JsonEncodedText propertyName, ReadOnlySpan <byte> utf8FormattedNumber)
{
JsonWriterHelper.ValidateValue(utf8FormattedNumber);
JsonWriterHelper.ValidateNumber(utf8FormattedNumber);
WriteNumberByOptions(propertyName.EncodedUtf8Bytes, utf8FormattedNumber);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
/// <summary>
/// Encodes the UTF-8 text value as a JSON string.
/// </summary>
/// <param name="utf8Value">The UTF-8 encoded value to be transformed as JSON encoded text.</param>
/// <exception cref="ArgumentException">
/// Thrown when the specified value is too large or if it contains invalid UTF-8 bytes.
/// </exception>
public static JsonEncodedText Encode(ReadOnlySpan <byte> utf8Value)
{
if (utf8Value.Length == 0)
{
return(new JsonEncodedText(Array.Empty <byte>()));
}
JsonWriterHelper.ValidateValue(utf8Value);
return(EncodeHelper(utf8Value));
}
/// <summary>
/// Writes the property name and value (as a JSON number) as part of a name/value pair of a JSON object.
/// </summary>
/// <param name="utf8PropertyName">The UTF-8 encoded name of the property to write..</param>
/// <param name="utf8FormattedNumber">The value to write.</param>
/// <exception cref="ArgumentException">
/// Thrown when the specified property name is too large.
/// </exception>
/// <exception cref="ArgumentException">
/// Thrown when <paramref name="utf8FormattedNumber"/> does not represent a valid JSON number.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Thrown if this would result in invalid JSON being written (while validation is enabled).
/// </exception>
/// <remarks>
/// Writes the <see cref="long"/> using the default <see cref="StandardFormat"/> (that is, 'G'), for example: 32767.
/// The property name is escaped before writing.
/// </remarks>
internal void WriteNumber(ReadOnlySpan <byte> utf8PropertyName, ReadOnlySpan <byte> utf8FormattedNumber)
{
JsonWriterHelper.ValidateProperty(utf8PropertyName);
JsonWriterHelper.ValidateValue(utf8FormattedNumber);
JsonWriterHelper.ValidateNumber(utf8FormattedNumber);
WriteNumberEscape(utf8PropertyName, utf8FormattedNumber);
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
/// <summary>
/// Writes the UTF-16 text value (as a JSON comment).
/// </summary>
/// <param name="value">The UTF-16 encoded value to be written as a UTF-8 transcoded JSON comment within /*..*/.</param>
/// <remarks>
/// The comment value is not escaped before writing.
/// </remarks>
/// <exception cref="ArgumentException">
/// Thrown when the specified value is too large OR if the given UTF-16 text value contains a comment delimiter (i.e. */).
/// </exception>
public void WriteCommentValue(ReadOnlySpan <char> value)
{
JsonWriterHelper.ValidateValue(value);
if (value.IndexOf(s_singleLineCommentDelimiter) != -1)
{
ThrowHelper.ThrowArgumentException_InvalidCommentValue();
}
WriteCommentByOptions(value);
}
/// <summary>
/// Writes the UTF-8 text value (as a JSON comment).
/// </summary>
/// <param name="utf8Value">The UTF-8 encoded value to be written as a JSON comment within /*..*/.</param>
/// <remarks>
/// The comment value is not escaped before writing.
/// </remarks>
/// <exception cref="ArgumentException">
/// Thrown when the specified value is too large OR if the given UTF-8 text value contains a comment delimiter (i.e. */).
/// </exception>
public void WriteCommentValue(ReadOnlySpan <byte> utf8Value)
{
JsonWriterHelper.ValidateValue(utf8Value);
if (utf8Value.IndexOf(SingleLineCommentDelimiterUtf8) != -1)
{
ThrowHelper.ThrowArgumentException_InvalidCommentValue();
}
WriteCommentByOptions(utf8Value);
}
/// <summary>
/// Internal version that keeps the existing string and byte[] references if there is no escaping required.
/// </summary>
internal static JsonEncodedText Encode(string stringValue, byte[] utf8Value, JavaScriptEncoder?encoder = null)
{
Debug.Assert(stringValue.Equals(JsonHelpers.Utf8GetString(utf8Value)));
if (utf8Value.Length == 0)
{
return(new JsonEncodedText(stringValue, utf8Value));
}
JsonWriterHelper.ValidateValue(utf8Value);
return(EncodeHelper(stringValue, utf8Value, encoder));
}
/// <summary>
/// Writes the UTF-16 text value (as a JSON comment).
/// </summary>
/// <param name="value">The UTF-16 encoded value to be written as a UTF-8 transcoded JSON comment within /*..*/.</param>
/// <param name="escape">If this is set to false, the writer assumes the value is properly escaped and skips the escaping step.</param>
/// <exception cref="ArgumentException">
/// Thrown when the specified value is too large.
/// </exception>
public void WriteCommentValue(ReadOnlySpan <char> value, bool escape = true)
{
JsonWriterHelper.ValidateValue(value);
if (escape)
{
WriteCommentEscape(value);
}
else
{
WriteCommentByOptions(value);
}
}
/// <summary>
/// Writes the UTF-16 text value (as a JSON string) as an element of a JSON array.
/// </summary>
/// <param name="value">The UTF-16 encoded value to be written as a UTF-8 transcoded JSON string element of a JSON array.</param>
/// <param name="escape">If this is set to false, the writer assumes the value is properly escaped and skips the escaping step.</param>
/// <exception cref="ArgumentException">
/// Thrown when the specified value is too large.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Thrown if this would result in an invalid JSON to be written (while validation is enabled).
/// </exception>
public void WriteStringValue(ReadOnlySpan <char> value, bool escape = true)
{
JsonWriterHelper.ValidateValue(value);
if (escape)
{
WriteStringEscape(value);
}
else
{
WriteStringByOptions(value);
}
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.String;
}
/// <summary>
/// Writes the value (as a JSON number) as an element of a JSON array.
/// </summary>
/// <param name="utf8FormattedNumber">The value to be written as a JSON number as an element of a JSON array.</param>
/// <exception cref="ArgumentException">
/// Thrown when <paramref name="utf8FormattedNumber"/> does not represent a valid JSON number.
/// </exception>
/// <exception cref="InvalidOperationException">
/// Thrown if this would result in an invalid JSON to be written (while validation is enabled).
/// </exception>
/// <remarks>
/// Writes the <see cref="int"/> using the default <see cref="StandardFormat"/> (i.e. 'G'), for example: 32767.
/// </remarks>
internal void WriteNumberValue(ReadOnlySpan <byte> utf8FormattedNumber)
{
JsonWriterHelper.ValidateValue(utf8FormattedNumber);
JsonWriterHelper.ValidateNumber(utf8FormattedNumber);
ValidateWritingValue();
if (Options.Indented)
{
WriteNumberValueIndented(utf8FormattedNumber);
}
else
{
WriteNumberValueMinimized(utf8FormattedNumber);
}
SetFlagToAddListSeparatorBeforeNextItem();
_tokenType = JsonTokenType.Number;
}
private static JsonEncodedText TranscodeAndEncode(ReadOnlySpan <char> value)
{
JsonWriterHelper.ValidateValue(value);
int expectedByteCount = JsonReaderHelper.GetUtf8ByteCount(value);
byte[] utf8Bytes = ArrayPool <byte> .Shared.Rent(expectedByteCount);
JsonEncodedText encodedText;
// Since GetUtf8ByteCount above already throws on invalid input, the transcoding
// to UTF-8 is guaranteed to succeed here. Therefore, there's no need for a try-catch-finally block.
int actualByteCount = JsonReaderHelper.GetUtf8FromText(value, utf8Bytes);
Debug.Assert(expectedByteCount == actualByteCount);
encodedText = EncodeHelper(utf8Bytes.AsSpan(0, actualByteCount));
// On the basis that this is user data, go ahead and clear it.
utf8Bytes.AsSpan(0, expectedByteCount).Clear();
ArrayPool <byte> .Shared.Return(utf8Bytes);
return(encodedText);
}