public double ReadDouble()
{
Align(8);
return(IsLittleEndian
? BinaryPrimitives.ReadDoubleLittleEndian(ReadBytes(8))
: BinaryPrimitives.ReadDoubleBigEndian(ReadBytes(8)));
}
public double ReadDouble()
{
CborInitialByte header = PeekInitialByte(expectedType: CborMajorType.Simple);
ReadOnlySpan <byte> buffer = GetRemainingBytes();
double result;
switch (header.AdditionalInfo)
{
case CborAdditionalInfo.Additional16BitData:
EnsureReadCapacity(buffer, 1 + SizeOfHalf);
result = ReadHalfBigEndian(buffer.Slice(1));
AdvanceBuffer(1 + SizeOfHalf);
AdvanceDataItemCounters();
return(result);
case CborAdditionalInfo.Additional32BitData:
EnsureReadCapacity(buffer, 1 + sizeof(float));
result = BinaryPrimitives.ReadSingleBigEndian(buffer.Slice(1));
AdvanceBuffer(1 + sizeof(float));
AdvanceDataItemCounters();
return(result);
case CborAdditionalInfo.Additional64BitData:
EnsureReadCapacity(buffer, 1 + sizeof(double));
result = BinaryPrimitives.ReadDoubleBigEndian(buffer.Slice(1));
AdvanceBuffer(1 + sizeof(double));
AdvanceDataItemCounters();
return(result);
default:
throw new InvalidOperationException(SR.Cbor_Reader_NotAFloatEncoding);
}
}
public double ReadDouble()
{
CborInitialByte header = PeekInitialByte(expectedType: CborMajorType.Special);
ReadOnlySpan <byte> buffer = _buffer.Span;
double result;
switch (header.AdditionalInfo)
{
case CborAdditionalInfo.Additional16BitData:
EnsureBuffer(buffer, 3);
result = ReadHalfBigEndian(buffer.Slice(1));
AdvanceBuffer(3);
AdvanceDataItemCounters();
return(result);
case CborAdditionalInfo.Additional32BitData:
EnsureBuffer(buffer, 5);
result = BinaryPrimitives.ReadSingleBigEndian(buffer.Slice(1));
AdvanceBuffer(5);
AdvanceDataItemCounters();
return(result);
case CborAdditionalInfo.Additional64BitData:
EnsureBuffer(buffer, 9);
result = BinaryPrimitives.ReadDoubleBigEndian(buffer.Slice(1));
AdvanceBuffer(9);
AdvanceDataItemCounters();
return(result);
default:
throw new InvalidOperationException("CBOR data item does not encode a floating point number.");
}
}
public double ReadDouble()
{
Span <byte> buffer = stackalloc byte[8];
this.Read(buffer);
return(BinaryPrimitives.ReadDoubleBigEndian(buffer));
}
public async Task <double> ReadDoubleAsync()
{
using var buffer = new RentedArray <byte>(sizeof(double));
await this.ReadAsync(buffer);
return(BinaryPrimitives.ReadDoubleBigEndian(buffer));
}
public double ReadAsDouble()
{
var value = BinaryPrimitives.ReadDoubleBigEndian(_span);
Advance(sizeof(double));
return(value);
}
public async Task <double> ReadDoubleAsync()
{
var buffer = new byte[8];
await this.ReadAsync(buffer);
return(BinaryPrimitives.ReadDoubleBigEndian(buffer));
}
private static object ParseValue(DataContentType dataContentType, ReadOnlySpan <byte> currentValueBytes)
{
return(dataContentType switch
{
DataContentType.DOUBLE => BinaryPrimitives.ReadDoubleBigEndian(currentValueBytes),
DataContentType.FLOAT => BinaryPrimitives.ReadSingleBigEndian(currentValueBytes),
DataContentType.BYTE => currentValueBytes[0],
DataContentType.SHORT => BinaryPrimitives.ReadInt16BigEndian(currentValueBytes),
DataContentType.INTEGER => BinaryPrimitives.ReadInt32BigEndian(currentValueBytes),
DataContentType.LONG => BinaryPrimitives.ReadInt64BigEndian(currentValueBytes) as object,
_ => throw new InvalidDataException("Invalid data type"),
});
public double GetDouble(int index, ByteOrder byteOrder)
{
var source = byteArray.AsSpan(index, sizeof(double));
if (byteOrder == ByteOrder.LittleEndian)
{
return(BinaryPrimitives.ReadDoubleLittleEndian(source));
}
if (byteOrder == ByteOrder.BigEndian)
{
return(BinaryPrimitives.ReadDoubleBigEndian(source));
}
return(double.NaN);
}
public static double GetBytesAsDoubleBigEndian(byte *b)
{
return(BinaryPrimitives.ReadDoubleBigEndian(new ReadOnlySpan <byte>(b, 8)));
}
public double ReadDoubleBigEndian() => BinaryPrimitives.ReadDoubleBigEndian(base.ReadBytes(8));
public double ReadDouble() => IsBigEndian?BinaryPrimitives.ReadDoubleBigEndian(Slice(8)) : BinaryPrimitives.ReadDoubleLittleEndian(Slice(8));
public override double ReadDouble() => BinaryPrimitives.ReadDoubleBigEndian(InternalRead(8));
public double ReadDoubleB() => BinaryPrimitives.ReadDoubleBigEndian(this.ReadBytes(sizeof(double)));
public static double ReadDoubleBigEndian(ReadOnlySpan <byte> source) => BinaryPrimitives.ReadDoubleBigEndian(source);
