private string FinishWriteUtf16String(ResizableMemory <byte> data) { try { var span = data.AsSpan(); if (Encodings.Utf8.ToUtf16Length(span, out int bytes) != OperationStatus.Done) { throw new SerializationException("Failed to convert to UTF16"); } var result = new String(' ', bytes / 2); unsafe { fixed(char *pResult = result) { var resultBytes = new Span <byte>((void *)pResult, bytes); if (Encodings.Utf8.ToUtf16(span, resultBytes, out _, out _) != OperationStatus.Done) { throw new SerializationException("Failed to convert to UTF16"); } } } return(result); } finally { _pool.Return(data.Array); } }
public override bool TryWrite(ref ResizableMemory <byte> writer, T[] value, PropertyMap propMap = null) { if (value == null) { return(EtfWriter.TryWriteNull(ref writer)); } var start = writer.Length; writer.Push((byte)EtfTokenType.List); writer.Advance(4); uint count = 0; for (int i = 0; i < value.Length; i++) { if (!_innerConverter.CanWrite(value[i], propMap)) { continue; } if (!_innerConverter.TryWrite(ref writer, value[i], propMap)) { return(false); } count++; } writer.Array[start + 1] = (byte)(count >> 24); writer.Array[start + 2] = (byte)(count >> 16); writer.Array[start + 3] = (byte)(count >> 8); writer.Array[start + 4] = (byte)count; writer.Push((byte)EtfTokenType.Nil); // Tail return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, int value, StandardFormat standardFormat) { if (standardFormat.IsDefault) { if (value <= byte.MaxValue && value >= byte.MinValue) { return(TryWrite(ref writer, (byte)value, standardFormat)); } writer.Push((byte)EtfTokenType.Integer); BinaryPrimitives.WriteInt32BigEndian(writer.RequestSpan(4), value); writer.Advance(4); } else { int start = writer.Length; writer.Push((byte)EtfTokenType.Binary); writer.Advance(4); if (!Utf8Writer.TryWrite(ref writer, value, standardFormat)) { return(false); } int length = writer.Length - start - 5; writer.Array[start + 1] = (byte)(length >> 24); writer.Array[start + 2] = (byte)(length >> 16); writer.Array[start + 3] = (byte)(length >> 8); writer.Array[start + 4] = (byte)length; } return(true); }
public ResizableMemory <byte> Write <T>(T value, ValueConverter <T> converter = null) { var writer = new ResizableMemory <byte>(1024, pool: _pool); Write(value, ref writer, converter); return(writer); }
public override bool TryWrite(ref ResizableMemory <byte> writer, Dictionary <string, T> value, PropertyMap propMap = null) { if (value == null) { return(JsonWriter.TryWriteNull(ref writer)); } writer.Push((byte)'{'); bool isFirst = true; foreach (var pair in value) { if (!isFirst) { writer.Push((byte)','); } else { isFirst = false; } if (!JsonWriter.TryWrite(ref writer, pair.Key)) { return(false); } writer.Push((byte)':'); if (!_innerConverter.TryWrite(ref writer, pair.Value, propMap)) { return(false); } } writer.Push((byte)'}'); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, char value) { ReadOnlySpan <char> chars = stackalloc char[] { value }; var charBytes = MemoryMarshal.AsBytes(chars); if (Encodings.Utf16.ToUtf8Length(charBytes, out var length) != OperationStatus.Done) { return(false); } var data = writer.Pool.Rent(length); try { if (Encodings.Utf16.ToUtf8(charBytes, data, out _, out _) != OperationStatus.Done) { return(false); } writer.Push((byte)'\"'); if (!TryWriteUtf8Bytes(ref writer, data.AsSpan(0, length))) { return(false); } writer.Push((byte)'\"'); } finally { writer.Pool.Return(data); } return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, bool value, StandardFormat standardFormat) { if (standardFormat.IsDefault) { if (value) { _trueValue.Span.CopyTo(writer.RequestSpan(6)); writer.Advance(6); } else { _falseValue.Span.CopyTo(writer.RequestSpan(7)); writer.Advance(7); } } else { int start = writer.Length; writer.Push((byte)EtfTokenType.Binary); writer.Advance(4); if (!Utf8Writer.TryWrite(ref writer, value, standardFormat)) { return(false); } int length = writer.Length - start - 5; writer.Array[start + 1] = (byte)(length >> 24); writer.Array[start + 2] = (byte)(length >> 16); writer.Array[start + 3] = (byte)(length >> 8); writer.Array[start + 4] = (byte)length; } return(true); }
public override bool TryWrite(ref ResizableMemory <byte> writer, TBase baseValue, PropertyMap propMap = null) { //if (!(baseValue is TValue value)) // return false; var value = (TValue)baseValue; return(_innerConverter.TryWrite(ref writer, value, propMap)); }
public static bool TryWriteString(ref ResizableMemory <byte> writer, ReadOnlySpan <byte> value) { var dstSpan = writer.RequestSpan(value.Length); value.CopyTo(dstSpan); writer.Advance(value.Length); return(true); }
public override bool TryWrite(ref ResizableMemory <byte> writer, T?value, PropertyMap propMap = null) { if (value == null) { return(JsonWriter.TryWriteNull(ref writer)); } return(_innerConverter.TryWrite(ref writer, value.Value, propMap)); }
public static bool TryWriteNull(ref ResizableMemory <byte> writer) { var data = writer.RequestSpan(4); // null const uint nullValue = ('n' << 24) + ('u' << 16) + ('l' << 8) + ('l' << 0); BinaryPrimitives.WriteUInt32BigEndian(data, nullValue); writer.Advance(4); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, decimal value, StandardFormat standardFormat = default) { writer.Push((byte)'"'); if (!Utf8Writer.TryWrite(ref writer, value, standardFormat)) { return(false); } writer.Push((byte)'"'); return(true); }
public override bool TryWrite(ref ResizableMemory <byte> writer, Topic value, PropertyMap propMap = null) { var dispatchUtf8 = _map.ToUtf8Key(value.DispatchType); if (_valueConverter.TryWrite(ref writer, dispatchUtf8.ToString() + "." + value.Id)) { return(true); } return(false); }
public static bool TryWrite(ref ResizableMemory <byte> writer, DateTimeOffset value, StandardFormat standardFormat) { writer.Push((byte)'"'); if (!Utf8Writer.TryWrite(ref writer, value, standardFormat)) { return(false); } writer.Push((byte)'"'); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, Utf8Span value) { writer.Push((byte)'\"'); if (!TryWriteUtf8Bytes(ref writer, value.Bytes)) { return(false); } writer.Push((byte)'\"'); return(true); }
public virtual void Write <T>(T value, ref ResizableMemory <byte> writer, ValueConverter <T> converter = null) { if (converter == null) { converter = _converters.Get <T>(this); } if (!converter.TryWrite(ref writer, value)) { throw new SerializationException($"Failed to serialize {typeof(T).Name}"); } }
public override bool TryWrite(ref ResizableMemory <byte> writer, T value, PropertyMap propMap = null) { if (_map.IsStringEnum) { return(_keyConverter.TryWrite(ref writer, _map.ToUtf8Key(value), propMap)); } else { return(_valueConverter.TryWrite(ref writer, _map.ToInt64(value), propMap)); } }
public static bool TryWrite(ref ResizableMemory <byte> writer, float value, StandardFormat standardFormat) { var data = writer.RequestSpan(14); // -3.402823E+038 if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public override bool TryWrite(ref ResizableMemory <byte> remaining, EntityOrId <T> value, PropertyMap propMap = null) { if (value.Object == null) { return(_idConverter.TryWrite(ref remaining, value.Id, propMap)); } else { return(_entityConverter.TryWrite(ref remaining, value.Object, propMap)); } }
public static bool TryWrite(ref ResizableMemory <byte> writer, TimeSpan value, StandardFormat standardFormat) { var data = writer.RequestSpan(26); // -10675199.02:48:05.4775808 if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, ulong value, StandardFormat standardFormat) { var data = writer.RequestSpan(29); // 18,446,744,073,709,551,615.00 if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, uint value, StandardFormat standardFormat) { var data = writer.RequestSpan(16); // 4,294,967,295.00 if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, double value, StandardFormat standardFormat) { var data = writer.RequestSpan(22); // -1.79769313486232E+308 if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public override bool TryWrite(ref ResizableMemory <byte> writer, Utf8String value, PropertyMap propMap = null) { if (value is null) { return(EtfWriter.TryWriteNull(ref writer)); } else { return(EtfWriter.TryWrite(ref writer, value)); } }
public static bool TryWrite(ref ResizableMemory <byte> writer, decimal value, StandardFormat standardFormat) { var data = writer.RequestSpan(30); // -79228162514264337593543950336 if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, Guid value, StandardFormat standardFormat) { var data = writer.RequestSpan(38); // {ABCDEFGH-ABCD-ABCD-ABCD-ABCDEFGHIJKL} if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, DateTimeOffset value, StandardFormat standardFormat) { var data = writer.RequestSpan(33); // 9999-12-31T11:59:59.999999+00:00 if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, long value, StandardFormat standardFormat) { var data = writer.RequestSpan(29); // -9,223,372,036,854,775,808.00 if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public static bool TryWrite(ref ResizableMemory <byte> writer, DateTime value, StandardFormat standardFormat) { // TODO: Will this break in other locales? var data = writer.RequestSpan(31); // Fri, 31 Dec 9999 11:59:59 ACWST if (!Utf8Formatter.TryFormat(value, data, out int bytesWritten, standardFormat)) { return(false); } writer.Advance(bytesWritten); return(true); }
public override bool TryWrite(TModel model, ref ResizableMemory <byte> buffer) { if (!TryGetWriteConverter(model, out var converter)) { return(false); } if (!converter.TryWrite(ref buffer, GetFunc(model), this)) { return(false); } return(true); }