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