public long ReadBEInt64()
{
long val = BinaryPrimitives.ReadInt64BigEndian(_buffer.Slice(Position, 8));
Position += 8;
return(val);
}
public long ReadAsLong()
{
var value = BinaryPrimitives.ReadInt64BigEndian(_span);
Advance(sizeof(long));
return(value);
}
public static long ReadInt64(this Stream source)
{
Span <byte> buffer = stackalloc byte[8];
source.Read(buffer);
return(BinaryPrimitives.ReadInt64BigEndian(buffer));
}
public long ReadInt64()
{
Span <byte> span = stackalloc byte[sizeof(long)];
ReadBytes(span);
return(BinaryPrimitives.ReadInt64BigEndian(span));
}
/// <summary>
/// Reads a double from a stream.
/// </summary>
/// <param name="s">The stream to be read</param>
/// <returns>The double read from stream</returns>
public static double ReadDouble(Stream s)
{
var buffer = GetThreadLocalBuffer(sizeof(long));
TryReadBytes(s, buffer, sizeof(long));
return(BitConverter.Int64BitsToDouble(BinaryPrimitives.ReadInt64BigEndian(buffer)));
}
protected static long ReadInt64(ref ReadOnlySpan <byte> data)
{
long val = BinaryPrimitives.ReadInt64BigEndian(data);
data = data.Slice(sizeof(long));
return(val);
}
/// <summary>
/// Reads a long integer from a stream.
/// </summary>
/// <param name="s">The stream to be read</param>
/// <returns>The long integer read from stream</returns>
public static long ReadInt64(Stream s)
{
var buffer = GetThreadLocalBuffer(sizeof(long));
TryReadBytes(s, buffer, sizeof(long));
return(BinaryPrimitives.ReadInt64BigEndian(buffer));
}
public async Task <long> ReadLongAsync()
{
using var buffer = new RentedArray <byte>(sizeof(long));
await this.ReadAsync(buffer);
return(BinaryPrimitives.ReadInt64BigEndian(buffer));
}
public long ReadInt64BigEndian()
{
var result = BinaryPrimitives.ReadInt64BigEndian(Buffer.AsSpan(Position, sizeof(long)));
Position += sizeof(long);
return(result);
}
public long ReadLong()
{
Span <byte> buffer = stackalloc byte[8];
this.Read(buffer);
return(BinaryPrimitives.ReadInt64BigEndian(buffer));
}
public long ReadInt64()
{
Align(8);
return(IsLittleEndian
? BinaryPrimitives.ReadInt64LittleEndian(ReadBytes(8))
: BinaryPrimitives.ReadInt64BigEndian(ReadBytes(8)));
}
/// <summary>
/// <see cref="ABCrypto"/> によって暗号化された価格を復号化します。
/// </summary>
/// <param name="crypto">暗号化オブジェクト。</param>
/// <param name="cipherBytes">暗号化された価格を表す暗号データ。</param>
/// <param name="price">復号化された価格。</param>
/// <returns>復号化に成功した場合は <c>true</c>、それ以外なら <c>false</c>。</returns>
/// <exception cref="ArgumentNullException"><paramref name="crypto"/> is <c>null</c>.</exception>
public static bool TryDecryptPrice(this ABCrypto crypto, ReadOnlySpan <byte> cipherBytes, out decimal price)
{
if (crypto == null)
{
throw new ArgumentNullException(nameof(crypto));
}
if (cipherBytes.Length != CipherSize)
{
goto Failure;
}
Span <byte> microPriceData = stackalloc byte[PricePayloadSize];
if (!crypto.TryDecrypt(cipherBytes, microPriceData, out _))
{
goto Failure;
}
price = (decimal)BinaryPrimitives.ReadInt64BigEndian(microPriceData) / MicrosPerCurrencyUnit;
return(true);
Failure:
price = default;
return(false);
}
public long ReadLong()
{
var b = BinaryPrimitives.ReadInt64BigEndian(Data.Slice(Position));
Position += sizeof(long);
return(b);
}
/// <inheritdoc />
public long ReadI8()
{
Span <byte> span = stackalloc byte[8];
_data.Read(span);
return(BinaryPrimitives.ReadInt64BigEndian(span));
}
public static long ReadLong(ref ReadOnlySpan <byte> buffer)
{
var ret = BinaryPrimitives.ReadInt64BigEndian(buffer);
buffer = buffer.Slice(8);
return(ret);
}
// Int64
public static long ReadInt64BigEndian(this MemoryUnit self, int offset)
{
Span <byte> buf = stackalloc byte[8];
self.Read(offset, buf);
return(BinaryPrimitives.ReadInt64BigEndian(buf));
}
public IByteProtocolBuffer Extract(out Int64 data)
{
var span = GetParseableSpan(sizeof(Int64));
data = BinaryPrimitives.ReadInt64BigEndian(span);
return(this);
}
public double readFloat(double defaultValue = 0)
{
uint cb = stream.readUint4();
switch (cb)
{
case 0:
return(defaultValue);
case 4:
Span <byte> span4 = stackalloc byte[4];
stream.read(span4);
int i4 = BinaryPrimitives.ReadInt32BigEndian(span4);
return(BitConverter.Int32BitsToSingle(i4));
case 8:
Span <byte> span8 = stackalloc byte[8];
stream.read(span8);
long i8 = BinaryPrimitives.ReadInt64BigEndian(span8);
return(BitConverter.Int64BitsToDouble(i8));
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Reads 64-bit long written in big-endian format.
/// </summary>
public long ReadInt64BigEndian()
{
long result = BinaryPrimitives.ReadInt64BigEndian(_span.Slice(_offset));
_offset += 8;
return(result);
}
public async Task <long> ReadLongAsync()
{
var buffer = new byte[8];
await this.ReadAsync(buffer);
return(BinaryPrimitives.ReadInt64BigEndian(buffer));
}
public long ReadInt64()
{
ReadOnlySpan <byte> span = new ReadOnlySpan <byte>(_input, (int)_position, 8);
Int64 value = BinaryPrimitives.ReadInt64BigEndian(span);
_position += 8;
return(value);
}
/// <summary>
/// Returns a long.
/// </summary>
/// <param name="index">The index.</param>
/// <returns>The value.</returns>
public long GetInt64(int index)
{
var span = this.Buffer.AsSpan(index, 8);
return(this.IsLittleEndian
? BinaryPrimitives.ReadInt64LittleEndian(span)
: BinaryPrimitives.ReadInt64BigEndian(span));
}
/// <summary>
/// Reads a 64-bit signed integer from the stream, using the bit converter
/// for this reader. 8 bytes are read.
/// </summary>
/// <returns>The 64-bit integer read</returns>
public long ReadInt64()
{
this.ReadInternal(this.storageBuffer, 8);
return((this.endianness == Endianness.BigEndian)
? BinaryPrimitives.ReadInt64BigEndian(this.storageBuffer)
: BinaryPrimitives.ReadInt64LittleEndian(this.storageBuffer));
}
public override async ValueTask <long> ReadI64Async(CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
await Trans.ReadAllAsync(PreAllocatedBuffer, 0, 8, cancellationToken);
return(BinaryPrimitives.ReadInt64BigEndian(PreAllocatedBuffer));
}
/// <summary>
/// 读取数值。
/// </summary>
/// <param name="buffer">当前只读字节实例。</param>
/// <returns>返回数值。</returns>
public static long ReadInt64(this ReadOnlySpan <byte> buffer)
{
if (BitConverter.IsLittleEndian)
{
return(BinaryPrimitives.ReadInt64BigEndian(buffer));
}
return(BinaryPrimitives.ReadInt64LittleEndian(buffer));
}
private long ReadSize(byte[] buffer)
{
if ((buffer[124] & 0x80) == 0x80) // if size in binary
{
return(BinaryPrimitives.ReadInt64BigEndian(buffer.AsSpan(0x80)));
}
return(ReadAsciiInt64Base8(buffer, 124, 11));
}
public double ReadDouble()
{
Span <byte> span = stackalloc byte[sizeof(long)];
ReadBytes(span);
var i = BinaryPrimitives.ReadInt64BigEndian(span);
return(BitConverter.Int64BitsToDouble(i));
}
public long ReadInt64()
{
long val = SwapEndian
? BinaryPrimitives.ReadInt64BigEndian(_buffer.Slice(Position, 8))
: BinaryPrimitives.ReadInt64LittleEndian(_buffer.Slice(Position, 8));
Position += 8;
return(val);
}
internal static long ReadInt64(ReadOnlySpan <byte> span)
{
if (span.Length < 8)
{
throw new ArgumentOutOfRangeException(nameof(span), "Insufficient length to decode Int64 from memory.");
}
return(BinaryPrimitives.ReadInt64BigEndian(span));
}
public static long ReadFixInt64(ReadOnlySpan <byte> buffer, out int readSize)
{
readSize = DataLengths.Int64;
if (buffer[0] != DataCodes.Int64)
{
ThrowWrongCodeException(buffer[0], DataCodes.Int64);
}
return(BinaryPrimitives.ReadInt64BigEndian(buffer.Slice(1)));
}
