public Task CopyToAsync(IWriteBytes destination, int bufferSize = 81920)
{
CopyTo(destination, bufferSize);
#if NET45
return(TaskUtils.CompletedTask);
#else
return(Task.CompletedTask);
#endif
}
const uint MORE_MASK = 0x80; // 1000 0000
public static void WriteCompressedUInt(this IWriteBytes stream, uint value)
{
while (value > DATA_MASK)
{
stream.WriteByte((byte)((value & DATA_MASK)));
value >>= 7;
}
stream.WriteByte((byte)(value | MORE_MASK));
}
public static void WriteCompressedDecimal(this IWriteBytes stream, decimal value)
{
value = value / 1.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000m;
var bits = decimal.GetBits(value);
stream.WriteCompressedInt(bits[0]);
stream.WriteCompressedInt(bits[1]);
stream.WriteCompressedInt(bits[2]);
stream.WriteCompressedInt(bits[3]);
}
/// <inheritdoc />
public void CopyTo(IWriteBytes destination, int bufferSize = 81920)
{
var buffer = new byte[bufferSize];
var bytesRead = Stream.Read(buffer, 0, bufferSize);
while (bytesRead > 0)
{
destination.WriteBytes(buffer, 0, bytesRead);
bytesRead = Stream.Read(buffer, 0, bufferSize);
}
}
public void CopyTo(IWriteBytes destination, int bufferSize = 81920)
{
var numBytes = (int)Min((long)int.MaxValue, BytesRemaining);
while (numBytes > 0)
{
_parent.ReadBytes(Position, numBytes, destination);
Position += numBytes;
numBytes = (int)Min((long)int.MaxValue, BytesRemaining);
}
}
public static void WriteCompressedNullableBool(this IWriteBytes stream, bool?value)
{
if (null == value)
{
stream.WriteByte(2);
}
else
{
stream.WriteByte(value.Value ? (byte)1 : (byte)0);
}
}
public void ReadBytes(long index, int count, IWriteBytes destination)
{
while (count > 0)
{
var readBuffer = _buffers[(int)(index / BufferSizeAsLong)];
var readIndex = (int)(index % BufferSizeAsLong);
var numBytes = Min(count, BufferSize - readIndex);
destination.WriteBytes(readBuffer, readIndex, numBytes);
index += numBytes;
count -= numBytes;
}
}
public static void WriteCompressedNullableUInt(this IWriteBytes stream, uint?value)
{
if (value.HasValue)
{
stream.WriteCompressedBool(true);
stream.WriteCompressedUInt(value.Value);
}
else
{
stream.WriteCompressedBool(false);
}
}
public static void WriteCompressedNullableLong(this IWriteBytes stream, long?value)
{
if (value.HasValue)
{
stream.WriteCompressedBool(true);
stream.WriteCompressedLong(value.Value);
}
else
{
stream.WriteCompressedBool(false);
}
}
public static void WriteDoubleOffset(this IWriteBytes stream, double seed, double tickSize, double value)
{
if (value == seed)
{
/// Since this is true 80% of the time in a trading platform, we use this optimization for significant performance gains.
stream.WriteCompressedInt(0);
}
else
{
stream.WriteCompressedInt(ToTicks(value - seed, tickSize));
}
}
public static void WriteNullableFullDouble(this IWriteBytes stream, double?value)
{
if (value.HasValue)
{
stream.WriteCompressedBool(true);
stream.WriteFullDouble(value.Value);
}
else
{
stream.WriteCompressedBool(false);
}
}
public static void WriteCompressedNullableDecimal(this IWriteBytes stream, decimal?value)
{
if (value.HasValue)
{
stream.WriteCompressedBool(true);
stream.WriteCompressedDecimal(value.Value);
}
else
{
stream.WriteCompressedBool(false);
}
}
public static void WriteCompressedNullableMonthStamp(this IWriteBytes stream, MonthStamp?value)
{
if (value.HasValue)
{
stream.WriteCompressedBool(true);
stream.WriteCompressedMonthStamp(value.Value);
}
else
{
stream.WriteCompressedBool(false);
}
}
/// <inheritdoc />
public async Task CopyToAsync(IWriteBytes destination, int bufferSize = 81920)
{
var buffer = new byte[bufferSize];
var bytesRead = await Stream.ReadAsync(buffer, 0, bufferSize).ConfigureAwait(false);
while (bytesRead > 0)
{
await destination.WriteBytesAsync(buffer, 0, bytesRead).ConfigureAwait(false);
bytesRead = await Stream.ReadAsync(buffer, 0, bufferSize).ConfigureAwait(false);
}
}
public static void WriteCompressedNullableEnum <T>(this IWriteBytes stream, T?value) where T : struct, Enum
{
if (value.HasValue)
{
stream.WriteCompressedBool(true);
stream.WriteCompressedEnum(value.Value);
}
else
{
stream.WriteCompressedBool(false);
}
}
public static void WriteCompressedNullableDateTime(this IWriteBytes stream, DateTime?value)
{
if (value.HasValue)
{
stream.WriteCompressedBool(true);
stream.WriteCompressedDateTime(value.Value);
}
else
{
stream.WriteCompressedBool(false);
}
}
public static void WriteCompressedByteArray(this IWriteBytes stream, byte[] bytes)
{
if (bytes is null)
{
stream.WriteCompressedBool(false);
}
else
{
stream.WriteCompressedBool(true);
stream.WriteCompressedUInt((uint)bytes.Length);
stream.WriteBytes(bytes);
}
}
public static void WriteCompressedString(this IWriteBytes stream, string value)
{
if (null == value)
{
stream.WriteCompressedBool(false);
}
else
{
stream.WriteCompressedBool(true);
var bytes = Encoding.GetBytes(value);
UIntCompressor.WriteCompressedUInt(stream, (uint)bytes.Length);
stream.WriteBytes(bytes, 0, bytes.Length);
}
}
public static void WriteCompressedEnum <T>(this IWriteBytes stream, T value) where T : Enum
{
stream.WriteCompressedInt((int)(object)value);
}
public static void WriteCompressedTimeStamp(this IWriteBytes stream, TimeStamp value)
{
stream.WriteCompressedLong(value.TicksUtc);
}
public static void WriteCompressedDateTime(this IWriteBytes stream, DateTime value)
{
stream.WriteCompressedLong(value.Ticks);
stream.WriteCompressedEnum(value.Kind);
}
public static void WriteCompressedInt(this IWriteBytes stream, int value)
{
stream.WriteCompressedUInt((uint)((value << 1) ^ (value >> 31)));
}
public static void WriteCompressedDateStamp(this IWriteBytes stream, DateStamp value)
{
stream.WriteCompressedUInt((uint)((value.Year * 12 + value.Month - 1) * 100 + value.Day));
}
public abstract void Compress(IWriteBytes stream, T value);
void ICompressor.Compress(IWriteBytes stream, object value) => Compress(stream, (T)value);
public static void WriteFullDouble(this IWriteBytes stream, double value)
{
stream.WriteBytes(BitConverter.GetBytes(value), 0, 8);
}
public static void WriteCompressedBool(this IWriteBytes stream, bool value)
{
stream.WriteByte(value ? (byte)1 : (byte)0);
}
public static void WriteCompressedMonthStamp(this IWriteBytes stream, MonthStamp value)
{
stream.WriteCompressedUInt((uint)(value.Year * 12 + value.Month - 1));
}
public override void Compress(IWriteBytes stream, T value) => Write(stream, value);
public static void WriteCompressedLong(this IWriteBytes stream, long value)
{
stream.WriteCompressedULong((ulong)((value << 1) ^ (value >> 63)));
}
