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