Add Buffered Reader (#3910)
This commit is contained in:
Kumaraswamy B G
GitHub
parent
3e9dd776e5
commit
b6563cf37a
193
src/main/java/com/thealgorithms/io/BufferedReader.java
Normal file
193
src/main/java/com/thealgorithms/io/BufferedReader.java
Normal file
@ -0,0 +1,193 @@
|
||||
package com.thealgorithms.io;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
/**
|
||||
* Mimics the actions of the Original buffered reader
|
||||
* implements other actions, such as peek(n) to lookahead,
|
||||
* block() to read a chunk of size {BUFFER SIZE}
|
||||
* <p>
|
||||
* Author: Kumaraswamy B.G (Xoma Dev)
|
||||
*/
|
||||
public class BufferedReader {
|
||||
|
||||
private static final int DEFAULT_BUFFER_SIZE = 5;
|
||||
|
||||
/**
|
||||
* Maximum number of bytes the buffer can hold.
|
||||
* Value is changed when encountered Eof to not
|
||||
* cause overflow read of 0 bytes
|
||||
*/
|
||||
|
||||
private int bufferSize;
|
||||
private final byte[] buffer;
|
||||
|
||||
/**
|
||||
* posRead -> indicates the next byte to read
|
||||
*/
|
||||
private int posRead = 0, bufferPos = 0;
|
||||
|
||||
private boolean foundEof = false;
|
||||
|
||||
private InputStream input;
|
||||
|
||||
public BufferedReader(byte[] input) throws IOException {
|
||||
this(new ByteArrayInputStream(input));
|
||||
}
|
||||
|
||||
public BufferedReader(InputStream input) throws IOException {
|
||||
this(input, DEFAULT_BUFFER_SIZE);
|
||||
}
|
||||
|
||||
public BufferedReader(InputStream input, int bufferSize) throws IOException {
|
||||
this.input = input;
|
||||
if (input.available() == -1)
|
||||
throw new IOException("Empty or already closed stream provided");
|
||||
|
||||
this.bufferSize = bufferSize;
|
||||
buffer = new byte[bufferSize];
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads a single byte from the stream
|
||||
*/
|
||||
public int read() throws IOException {
|
||||
if (needsRefill()) {
|
||||
if (foundEof)
|
||||
return -1;
|
||||
// the buffer is empty, or the buffer has
|
||||
// been completely read and needs to be refilled
|
||||
refill();
|
||||
}
|
||||
return buffer[posRead++] & 0xff; // read and un-sign it
|
||||
}
|
||||
|
||||
/**
|
||||
* Number of bytes not yet been read
|
||||
*/
|
||||
|
||||
public int available() throws IOException {
|
||||
int available = input.available();
|
||||
if (needsRefill())
|
||||
// since the block is already empty,
|
||||
// we have no responsibility yet
|
||||
return available;
|
||||
return bufferPos - posRead + available;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the next character
|
||||
*/
|
||||
|
||||
public int peek() throws IOException {
|
||||
return peek(1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Peeks and returns a value located at next {n}
|
||||
*/
|
||||
|
||||
public int peek(int n) throws IOException {
|
||||
int available = available();
|
||||
if (n >= available)
|
||||
throw new IOException("Out of range, available %d, but trying with %d"
|
||||
.formatted(available, n));
|
||||
pushRefreshData();
|
||||
|
||||
if (n >= bufferSize)
|
||||
throw new IllegalAccessError("Cannot peek %s, maximum upto %s (Buffer Limit)"
|
||||
.formatted(n, bufferSize));
|
||||
return buffer[n];
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the already read bytes from the buffer
|
||||
* in-order to make space for new bytes to be filled up.
|
||||
* <p>
|
||||
* This may also do the job to read first time data (whole buffer is empty)
|
||||
*/
|
||||
|
||||
private void pushRefreshData() throws IOException {
|
||||
for (int i = posRead, j = 0; i < bufferSize; i++, j++)
|
||||
buffer[j] = buffer[i];
|
||||
|
||||
bufferPos -= posRead;
|
||||
posRead = 0;
|
||||
|
||||
// fill out the spaces that we've
|
||||
// emptied
|
||||
justRefill();
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads one complete block of size {bufferSize}
|
||||
* if found eof, the total length of array will
|
||||
* be that of what's available
|
||||
*
|
||||
* @return a completed block
|
||||
*/
|
||||
public byte[] readBlock() throws IOException {
|
||||
pushRefreshData();
|
||||
|
||||
byte[] cloned = new byte[bufferSize];
|
||||
// arraycopy() function is better than clone()
|
||||
if (bufferPos >= 0)
|
||||
System.arraycopy(buffer,
|
||||
0,
|
||||
cloned,
|
||||
0,
|
||||
// important to note that, bufferSize does not stay constant
|
||||
// once the class is defined. See justRefill() function
|
||||
bufferSize);
|
||||
// we assume that already a chunk
|
||||
// has been read
|
||||
refill();
|
||||
return cloned;
|
||||
}
|
||||
|
||||
private boolean needsRefill() {
|
||||
return bufferPos == 0 || posRead == bufferSize;
|
||||
}
|
||||
|
||||
private void refill() throws IOException {
|
||||
posRead = 0;
|
||||
bufferPos = 0;
|
||||
justRefill();
|
||||
}
|
||||
|
||||
private void justRefill() throws IOException {
|
||||
assertStreamOpen();
|
||||
|
||||
// try to fill in the maximum we can until
|
||||
// we reach EOF
|
||||
while (bufferPos < bufferSize) {
|
||||
int read = input.read();
|
||||
if (read == -1) {
|
||||
// reached end-of-file, no more data left
|
||||
// to be read
|
||||
foundEof = true;
|
||||
// rewrite the BUFFER_SIZE, to know that we've reached
|
||||
// EOF when requested refill
|
||||
bufferSize = bufferPos;
|
||||
}
|
||||
buffer[bufferPos++] = (byte) read;
|
||||
}
|
||||
}
|
||||
|
||||
private void assertStreamOpen() {
|
||||
if (input == null)
|
||||
throw new IllegalStateException("Input Stream already closed!");
|
||||
}
|
||||
|
||||
public void close() throws IOException {
|
||||
if (input != null) {
|
||||
try {
|
||||
input.close();
|
||||
} finally {
|
||||
input = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
133
src/test/java/com/thealgorithms/io/BufferedReaderTest.java
Normal file
133
src/test/java/com/thealgorithms/io/BufferedReaderTest.java
Normal file
@ -0,0 +1,133 @@
|
||||
package com.thealgorithms.io;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.util.*;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class BufferedReaderTest {
|
||||
@Test
|
||||
public void testPeeks() throws IOException {
|
||||
String text = "Hello!\nWorld!";
|
||||
int len = text.length();
|
||||
byte[] bytes = text.getBytes();
|
||||
|
||||
ByteArrayInputStream input = new ByteArrayInputStream(bytes);
|
||||
BufferedReader reader = new BufferedReader(input);
|
||||
|
||||
// read the first letter
|
||||
assertEquals(reader.read(), 'H');
|
||||
len--;
|
||||
assertEquals(reader.available(), len);
|
||||
|
||||
// position: H[e]llo!\nWorld!
|
||||
// reader.read() will be == 'e'
|
||||
assertEquals(reader.peek(1), 'l');
|
||||
assertEquals(reader.peek(2), 'l'); // second l
|
||||
assertEquals(reader.peek(3), 'o');
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMixes() throws IOException {
|
||||
String text = "Hello!\nWorld!";
|
||||
int len = text.length();
|
||||
byte[] bytes = text.getBytes();
|
||||
|
||||
ByteArrayInputStream input = new ByteArrayInputStream(bytes);
|
||||
BufferedReader reader = new BufferedReader(input);
|
||||
|
||||
// read the first letter
|
||||
assertEquals(reader.read(), 'H'); // first letter
|
||||
len--;
|
||||
|
||||
assertEquals(reader.peek(1), 'l'); // third later (second letter after 'H')
|
||||
assertEquals(reader.read(), 'e'); // second letter
|
||||
len--;
|
||||
assertEquals(reader.available(), len);
|
||||
|
||||
// position: H[e]llo!\nWorld!
|
||||
assertEquals(reader.peek(2), 'o'); // second l
|
||||
assertEquals(reader.peek(3), '!');
|
||||
assertEquals(reader.peek(4), '\n');
|
||||
|
||||
assertEquals(reader.read(), 'l'); // third letter
|
||||
assertEquals(reader.peek(1), 'o'); // fourth letter
|
||||
|
||||
for (int i = 0; i < 6; i++)
|
||||
reader.read();
|
||||
try {
|
||||
System.out.println((char) reader.peek(4));
|
||||
} catch (Exception ignored) {
|
||||
System.out.println("[cached intentional error]");
|
||||
// intentional, for testing purpose
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBlockPractical() throws IOException {
|
||||
String text = "!Hello\nWorld!";
|
||||
byte[] bytes = text.getBytes();
|
||||
int len = bytes.length;
|
||||
|
||||
ByteArrayInputStream input = new ByteArrayInputStream(bytes);
|
||||
BufferedReader reader = new BufferedReader(input);
|
||||
|
||||
|
||||
assertEquals(reader.peek(), 'H');
|
||||
assertEquals(reader.read(), '!'); // read the first letter
|
||||
len--;
|
||||
|
||||
// this only reads the next 5 bytes (Hello) because
|
||||
// the default buffer size = 5
|
||||
assertEquals(new String(reader.readBlock()), "Hello");
|
||||
len -= 5;
|
||||
assertEquals(reader.available(), len);
|
||||
|
||||
// maybe kind of a practical demonstration / use case
|
||||
if (reader.read() == '\n') {
|
||||
assertEquals(reader.read(), 'W');
|
||||
assertEquals(reader.read(), 'o');
|
||||
|
||||
// the rest of the blocks
|
||||
assertEquals(new String(reader.readBlock()), "rld!");
|
||||
} else {
|
||||
// should not reach
|
||||
throw new IOException("Something not right");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void randomTest() throws IOException {
|
||||
Random random = new Random();
|
||||
|
||||
int len = random.nextInt(9999);
|
||||
int bound = 256;
|
||||
|
||||
ByteArrayOutputStream stream = new ByteArrayOutputStream(len);
|
||||
while (len-- > 0)
|
||||
stream.write(random.nextInt(bound));
|
||||
|
||||
byte[] bytes = stream.toByteArray();
|
||||
ByteArrayInputStream comparer = new ByteArrayInputStream(bytes);
|
||||
|
||||
int blockSize = random.nextInt(7) + 5;
|
||||
BufferedReader reader = new BufferedReader(
|
||||
new ByteArrayInputStream(bytes), blockSize);
|
||||
|
||||
for (int i = 0; i < 50; i++) {
|
||||
if ((i & 1) == 0) {
|
||||
assertEquals(comparer.read(), reader.read());
|
||||
continue;
|
||||
}
|
||||
byte[] block = new byte[blockSize];
|
||||
comparer.read(block);
|
||||
byte[] read = reader.readBlock();
|
||||
|
||||
assertArrayEquals(block, read);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user