public static int ReadIntBlock(BufferedReader reader, int[] values, int length)
{
int available = Math.Min(4 * length, reader.EnsureSpace(4 * length));
Buffer.BlockCopy(reader.Buffer, reader.Index, values, 0, available);
reader.Index += available;
return(available / 4);
}
public static int ReadInt32(this BufferedReader reader)
{
reader.EnsureSpace(4);
int value = (int)(reader.Buffer[reader.Index] | reader.Buffer[reader.Index + 1] << 8 | reader.Buffer[reader.Index + 2] << 16 | reader.Buffer[reader.Index + 3] << 24);
reader.Index += 4;
return(value);
}
/// <summary>
/// Construct a BufferedReader to read a file in one buffer.
/// </summary>
/// <param name="filePath">File to Read</param>
/// <returns>BufferedReader to read whole file</returns>
public static BufferedReader ReadAll(string filePath)
{
long fileSize = new FileInfo(filePath).Length;
BufferedReader reader = new BufferedReader(File.OpenRead(filePath), new byte[fileSize + 1]);
reader.EnsureSpace((int)(fileSize + 1));
return(reader);
}
/// <summary>
/// Read the next bytes from the reader as a variable length,
/// 7-bit encoded integer.
/// </summary>
/// <param name="reader">BufferedReader to read from</param>
/// <returns>Value read</returns>
public static ulong ReadSevenBitExplicit(BufferedReader reader, int length)
{
reader.EnsureSpace(length);
ulong value = 0;
int shift = 0;
for (int i = 0; i < length; ++i)
{
value += (ulong)(reader.Buffer[reader.Index++] & 0x7F) << shift;
shift += 7;
}
return(value);
}
public bool ReadBlock(out int[] block)
{
if (_reader.EndOfStream)
{
block = null;
return(false);
}
_reader.EnsureSpace(4 + BlockSize / 4 + BlockSize * 4);
// Read delta
//int deltaBase = _reader.ReadInt32();
// Skip over control bytes
int controlStart = _reader.Index;
_reader.Index += (BlockSize / 4);
int controlByte = 0;
for (int i = 0; i < BlockSize; ++i)
{
if (i % 4 == 0)
{
controlByte = _reader.Buffer[controlStart + i / 4];
}
// Read control byte
int byteLength = ((controlByte & 0xC0) >> 6) + 1;
controlByte = controlByte << 2;
// Read value bytes
int value = 0;
for (int j = 0; j < byteLength; ++j)
{
value = value << 8;
value += _reader.Buffer[_reader.Index++];
}
//// Add delta
//value += deltaBase;
_buffer[i] = value;
}
block = _buffer;
return(true);
}
/// <summary>
/// Read the next bytes from the reader as a variable length,
/// 7-bit encoded integer.
/// </summary>
/// <param name="reader">BufferedReader to read from</param>
/// <returns>Value read</returns>
public static ulong ReadSevenBitTerminated(BufferedReader reader)
{
reader.EnsureSpace(10);
ulong value = 0;
int current = 0, shift = 0;
while (current <= 0x7F)
{
current = reader.Buffer[reader.Index++];
value += (ulong)(current & 0x7F) << shift;
shift += 7;
}
return(value);
}
/// <summary>
/// Read the next bytes from the reader as a variable length,
/// 6-bit encoded integer.
/// </summary>
/// <param name="reader">BufferedReader to read from</param>
/// <returns>Value read</returns>
public static int ReadSixBitTerminatedBlock(BufferedReader reader, ulong[] block)
{
reader.EnsureSpace(block.Length * 11);
int index = 0;
while (index < block.Length && !reader.EndOfStream)
{
ulong value = 0;
int current = 0, shift = 0;
while (current <= 0x3F)
{
current = reader.Buffer[reader.Index++];
value += (ulong)(current & 0x3F) << shift;
shift += 6;
}
block[index++] = value;
}
return(index);
}
