//
// 16 bit
//
/// <summary>
/// Reads an Int16 without advancing the read pointer
/// </summary>
public Int16 PeekInt16()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 16);
uint retval = BitReaderWriter.ReadUInt16(_data, 16, _readPosition);
return((short)retval);
}
//
// 1 bit
//
/// <summary>
/// Reads a 1-bit Boolean without advancing the read pointer
/// </summary>
public bool PeekBoolean()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 1);
byte retval = BitReaderWriter.ReadByte(_data, 1, _readPosition);
return(retval > 0 ? true : false);
}
/// <summary>
/// Reads an SByte without advancing the read pointer
/// </summary>
public sbyte PeekSByte()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 8);
byte retval = BitReaderWriter.ReadByte(_data, 8, _readPosition);
return((sbyte)retval);
}
/// <summary>
/// Reads a UInt32 without advancing the read pointer
/// </summary>
public UInt32 PeekUInt32()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 32);
uint retval = BitReaderWriter.ReadUInt32(_data, 32, _readPosition);
return(retval);
}
/// <summary>
/// Reads the specified number of bits into an Int32 without advancing the read pointer
/// </summary>
public Int32 PeekInt32(int numberOfBits)
{
BitBufferException.Assert((numberOfBits > 0 && numberOfBits <= 32), "ReadInt() can only read between 1 and 32 bits");
ReadOverflowException.Assert(_lengthBits - _readPosition >= numberOfBits);
uint retval = BitReaderWriter.ReadUInt32(_data, numberOfBits, _readPosition);
if (numberOfBits == 32)
{
return((int)retval);
}
int signBit = 1 << (numberOfBits - 1);
if ((retval & signBit) == 0)
{
return((int)retval); // positive
}
// negative
unchecked
{
uint mask = ((uint)-1) >> (33 - numberOfBits);
uint tmp = (retval & mask) + 1;
return(-((int)tmp));
}
}
/// <summary>
/// Reads the specified number of bytes without advancing the read pointer
/// </summary>
public void PeekBytes(byte[] into, int offset, int numberOfBytes)
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= (numberOfBytes * 8));
BitBufferException.Assert(offset + numberOfBytes <= into.Length);
BitReaderWriter.ReadBytes(_data, numberOfBytes, _readPosition, into, offset);
return;
}
/// <summary>
/// Reads the specified number of bytes without advancing the read pointer
/// </summary>
public byte[] PeekBytes(int numberOfBytes)
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= (numberOfBytes * 8));
byte[] retval = new byte[numberOfBytes];
BitReaderWriter.ReadBytes(_data, numberOfBytes, _readPosition, retval, 0);
return(retval);
}
/// <summary>
/// Reads a byte
/// </summary>
public byte ReadByte()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 8);
byte retval = BitReaderWriter.ReadByte(_data, 8, _readPosition);
_readPosition += 8;
return(retval);
}
/// <summary>
/// Reads an Int64 without advancing the read pointer
/// </summary>
public Int64 PeekInt64()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 64);
unchecked
{
ulong retval = PeekUInt64();
long longRetval = (long)retval;
return(longRetval);
}
}
//
// 64 bit
//
/// <summary>
/// Reads a UInt64 without advancing the read pointer
/// </summary>
public UInt64 PeekUInt64()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 64);
ulong low = BitReaderWriter.ReadUInt32(_data, 32, _readPosition);
ulong high = BitReaderWriter.ReadUInt32(_data, 32, _readPosition + 32);
ulong retval = low + (high << 32);
return(retval);
}
/// <summary>
/// Reads a 32-bit Single without advancing the read pointer
/// </summary>
public float PeekSingle()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 32);
if ((_readPosition & 7) == 0) // read directly
{
float retval = BitConverter.ToSingle(_data, _readPosition >> 3);
return(retval);
}
byte[] bytes = PeekBytes(4);
return(BitConverter.ToSingle(bytes, 0));
}
/// <summary>
/// Reads a 64-bit Double without advancing the read pointer
/// </summary>
public double PeekDouble()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 64);
if ((_readPosition & 7) == 0) // read directly
{
// read directly
double retval = BitConverter.ToDouble(_data, _readPosition >> 3);
return(retval);
}
byte[] bytes = PeekBytes(8);
return(BitConverter.ToDouble(bytes, 0));
}
/// <summary>
/// Reads the specified number of bits into an UInt64 without advancing the read pointer
/// </summary>
public UInt64 PeekUInt64(int numberOfBits)
{
BitBufferException.Assert((numberOfBits > 0 && numberOfBits <= 64), "ReadUInt() can only read between 1 and 64 bits");
ReadOverflowException.Assert(_lengthBits - _readPosition >= numberOfBits);
ulong retval;
if (numberOfBits <= 32)
{
retval = (ulong)BitReaderWriter.ReadUInt32(_data, numberOfBits, _readPosition);
}
else
{
retval = BitReaderWriter.ReadUInt32(_data, 32, _readPosition);
retval |= (UInt64)BitReaderWriter.ReadUInt32(_data, numberOfBits - 32, _readPosition + 32) << 32;
}
return(retval);
}
/// <summary>
/// Reads a 32 bit floating point value written using Write(Single)
/// </summary>
public float ReadSingle()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 32);
if ((_readPosition & 7) == 0) // read directly
{
float retval = BitConverter.ToSingle(_data, _readPosition >> 3);
_readPosition += 32;
return(retval);
}
byte[] bytes = (byte[])Interlocked.Exchange(ref _buffer, null) ?? new byte[BufferSize];
ReadBytes(bytes, 0, 4);
float res = BitConverter.ToSingle(bytes, 0);
_buffer = bytes;
return(res);
}
/// <summary>
/// Reads the specified number of bits into a preallocated array
/// </summary>
/// <param name="into">The destination array</param>
/// <param name="offset">The offset where to start writing in the destination array</param>
/// <param name="numberOfBits">The number of bits to read</param>
public BitReader ReadBits(byte[] into, int offset, int numberOfBits)
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= numberOfBits);
BitBufferException.Assert(offset + BitUtility.BytesToHoldBits(numberOfBits) <= into.Length);
int numberOfWholeBytes = numberOfBits / 8;
int extraBits = numberOfBits - (numberOfWholeBytes * 8);
BitReaderWriter.ReadBytes(_data, numberOfWholeBytes, _readPosition, into, offset);
_readPosition += (8 * numberOfWholeBytes);
if (extraBits > 0)
{
into[offset + numberOfWholeBytes] = ReadByte(extraBits);
}
return(this);
}
/// <summary>
/// Reads a 64 bit floating point value written using Write(Double)
/// </summary>
public double ReadDouble()
{
ReadOverflowException.Assert(_lengthBits - _readPosition >= 64);
if ((_readPosition & 7) == 0) // read directly
{
// read directly
double retval = BitConverter.ToDouble(_data, _readPosition >> 3);
_readPosition += 64;
return(retval);
}
byte[] bytes = (byte[])Interlocked.Exchange(ref _buffer, null) ?? new byte[BufferSize];
ReadBytes(bytes, 0, 8);
double res = BitConverter.ToDouble(bytes, 0);
_buffer = bytes;
return(res);
}