public sealed override void Write(string value, Span <byte> buffer, ref int offset)
{
//WARNING: Doing use this calculated string length in ANYTHING but writing, it may contain adjusted sizes.
//We must write the length prefix first into the buffer
int stringLength = CalculateOutgoingStringLength(value);
stringLength++; //add terminator character
GenericTypePrimitiveSerializerStrategy <TLengthType> .Instance.Write(stringLength.Reinterpret <int, TLengthType>(), buffer, ref offset);
int expectedByteLength = value.Length * MaximumCharacterSize;
int lastOffset = offset;
DecoratedSerializer.Write(value, buffer.Slice(0, expectedByteLength + offset), ref offset);
//TODO: This is a COMPLETE hack that should be toggleable honestly.
//This isn't *really* how we should handle variable length encodings and stuff, but PSOBB does fixed-length UTF16 for fixed/known size
//So to compensate for this we adjust the buffer offset to pretend we're fixed-length
if (offset != lastOffset + expectedByteLength)
{
while (offset < lastOffset + expectedByteLength)
{
GenericTypePrimitiveSerializerStrategy <byte> .Instance.Write(0, buffer, ref offset);
}
}
//Now we can write terminator
DecoratedTerminatorStrategy.Write(value, buffer, ref offset);
}
public sealed override string Read(Span <byte> buffer, ref int offset)
{
int length = CalculateIncomingStringLength(buffer, ref offset);
if (length == 0 || length < MaximumCharacterSize)
{
return(String.Empty);
}
//Read until terminator is found, then we skip over terminator in the buffer.
//Slice just incase invalid data and terminator isn't there.
string value = DecoratedSerializer.Read(buffer.Slice(0, (length) * MaximumCharacterSize + offset), ref offset);
return(value);
}
public Task <TType> ReadAsync([NotNull] IWireStreamReaderStrategyAsync source)
{
return(DecoratedSerializer.ReadAsync(source));
}
public TType Read([NotNull] IWireStreamReaderStrategy source)
{
return(DecoratedSerializer.Read(source));
}
public Task ObjectIntoWriterAsync([CanBeNull] object obj, [NotNull] IWireStreamWriterStrategyAsync dest)
{
return(DecoratedSerializer.ObjectIntoWriterAsync(obj, dest));
}
public void ObjectIntoWriter([CanBeNull] object obj, [NotNull] IWireStreamWriterStrategy dest)
{
DecoratedSerializer.ObjectIntoWriter(obj, dest);
}
public byte[] GetBytes([NotNull] object obj)
{
return(DecoratedSerializer.GetBytes(obj));
}
public TType FromBytes([NotNull] byte[] bytes)
{
return(DecoratedSerializer.FromBytes(bytes));
}
async Task <object> ITypeSerializerStrategyAsync.ReadAsync(IWireStreamReaderStrategyAsync source)
{
return(await DecoratedSerializer.ReadAsync(source)
.ConfigureAwait(false));
}
object ITypeSerializerStrategy.Read(IWireStreamReaderStrategy source)
{
return(DecoratedSerializer.Read(source));
}
object IObjectByteReader.FromBytes(byte[] bytes)
{
return(DecoratedSerializer.FromBytes(bytes));
}
public Task WriteAsync(object value, [NotNull] IWireStreamWriterStrategyAsync dest)
{
return(DecoratedSerializer.WriteAsync(value, dest));
}
public void Write(object value, [NotNull] IWireStreamWriterStrategy dest)
{
DecoratedSerializer.Write(value, dest);
}
public Task <object> ReadIntoObjectAsync([CanBeNull] object obj, [NotNull] IWireStreamReaderStrategyAsync source)
{
return(DecoratedSerializer.ReadIntoObjectAsync(obj, source));
}
public object ReadIntoObject([CanBeNull] object obj, [NotNull] IWireStreamReaderStrategy source)
{
return(DecoratedSerializer.ReadIntoObject(obj, source));
}
