/// <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); }