input stream backing

Author: bosborn

src/main/java/mil/nga/sf/util/ByteReader.java

@@ -1,8 +1,12 @@
 package mil.nga.sf.util;
 
-import java.io.UnsupportedEncodingException;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.util.logging.Level;
+import java.util.logging.Logger;
 
 /**
  * Read through a byte array
@@ -11,20 +15,31 @@
  */
 public class ByteReader {
 
+	/**
+	 * Logger
+	 */
+	private static final Logger logger = Logger
+			.getLogger(ByteReader.class.getName());
+
 	/**
 	 * Character set
 	 */
 	private static final String CHAR_SET = "UTF-8";
 
 	/**
-	 * Next byte index to read
+	 * Bytes to read from
 	 */
-	private int nextByte = 0;
+	private final byte[] bytes;
 
 	/**
-	 * Bytes to read
+	 * Input stream to read bytes from
 	 */
-	private final byte[] bytes;
+	private final InputStream inputStream;
+
+	/**
+	 * Next byte index to read
+	 */
+	private int nextByte = 0;
 
 	/**
 	 * Byte order
@@ -39,6 +54,83 @@ public class ByteReader {
 	 */
 	public ByteReader(byte[] bytes) {
 		this.bytes = bytes;
+		inputStream = new ByteArrayInputStream(bytes);
+	}
+
+	/**
+	 * Constructor
+	 * 
+	 * @param inputStream
+	 *            input stream
+	 * @since 2.0.3
+	 */
+	public ByteReader(InputStream inputStream) {
+		this.bytes = null;
+		this.inputStream = inputStream;
+	}
+
+	/**
+	 * Constructor
+	 * 
+	 * @param bytes
+	 *            bytes
+	 * @param byteOrder
+	 *            byte order
+	 * @since 2.0.3
+	 */
+	public ByteReader(byte[] bytes, ByteOrder byteOrder) {
+		this(bytes);
+		this.byteOrder = byteOrder;
+	}
+
+	/**
+	 * Constructor
+	 * 
+	 * @param inputStream
+	 *            input stream
+	 * @param byteOrder
+	 *            byte order
+	 * @since 2.0.3
+	 */
+	public ByteReader(InputStream inputStream, ByteOrder byteOrder) {
+		this(inputStream);
+		this.byteOrder = byteOrder;
+	}
+
+	/**
+	 * Get the bytes
+	 * 
+	 * @return bytes
+	 * 
+	 * @since 2.0.3
+	 */
+	public byte[] getBytes() {
+		return bytes;
+	}
+
+	/**
+	 * Get the output stream
+	 * 
+	 * @return output stream
+	 * 
+	 * @since 2.0.3
+	 */
+	public InputStream getInputStream() {
+		return inputStream;
+	}
+
+	/**
+	 * Close the byte reader
+	 * 
+	 * @since 2.0.3
+	 */
+	public void close() {
+		try {
+			inputStream.close();
+		} catch (IOException e) {
+			logger.log(Level.WARNING,
+					"Failed to close byte reader intput stream", e);
+		}
 	}
 
 	/**
@@ -75,47 +167,60 @@ public void setByteOrder(ByteOrder byteOrder) {
 	 * @param num
 	 *            number of bytes
 	 * @return String
-	 * @throws UnsupportedEncodingException
+	 * @throws IOException
+	 *             upon error
+	 */
+	public String readString(int num) throws IOException {
+		return new String(readBytes(num), CHAR_SET);
+	}
+
+	/**
+	 * Read the number of bytes
+	 * 
+	 * @param num
+	 *            number of bytes
+	 * @return bytes
+	 * @throws IOException
 	 *             upon error
 	 */
-	public String readString(int num) throws UnsupportedEncodingException {
+	public byte[] readBytes(int num) throws IOException {
 		verifyRemainingBytes(num);
-		String value = new String(bytes, nextByte, num, CHAR_SET);
+		byte[] bytes = new byte[num];
+		inputStream.read(bytes);
 		nextByte += num;
-		return value;
+		return bytes;
 	}
 
 	/**
 	 * Read a byte
 	 * 
 	 * @return byte
+	 * @throws IOException
+	 *             upon error
 	 */
-	public byte readByte() {
-		verifyRemainingBytes(1);
-		byte value = bytes[nextByte];
-		nextByte++;
-		return value;
+	public byte readByte() throws IOException {
+		return readBytes(1)[0];
 	}
 
 	/**
 	 * Read an integer
 	 * 
 	 * @return integer
+	 * @throws IOException
+	 *             upon error
 	 */
-	public int readInt() {
-		verifyRemainingBytes(4);
-		int value = ByteBuffer.wrap(bytes, nextByte, 4).order(byteOrder)
-				.getInt();
-		nextByte += 4;
-		return value;
+	public int readInt() throws IOException {
+		return ByteBuffer.wrap(readBytes(4)).order(byteOrder).getInt();
 	}
 
 	/**
 	 * Read an unsigned integer
 	 * 
 	 * @return unsigned integer
+	 * @throws IOException
+	 *             upon error
 	 */
-	public long readUnsignedInt() {
+	public long readUnsignedInt() throws IOException {
 		int intValue = readInt();
 		long value = intValue & 0xffffffffL;
 		return value;
@@ -125,13 +230,11 @@ public long readUnsignedInt() {
 	 * Read a double
 	 * 
 	 * @return double
+	 * @throws IOException
+	 *             upon error
 	 */
-	public double readDouble() {
-		verifyRemainingBytes(8);
-		double value = ByteBuffer.wrap(bytes, nextByte, 8).order(byteOrder)
-				.getDouble();
-		nextByte += 8;
-		return value;
+	public double readDouble() throws IOException {
+		return ByteBuffer.wrap(readBytes(8)).order(byteOrder).getDouble();
 	}
 
 	/**
@@ -142,11 +245,11 @@ public double readDouble() {
 	 *            number of bytes to read
 	 */
 	private void verifyRemainingBytes(int bytesToRead) {
-		if (nextByte + bytesToRead > bytes.length) {
+		if (bytes != null && nextByte + bytesToRead > bytes.length) {
 			throw new SFException(
 					"No more remaining bytes to read. Total Bytes: "
-							+ bytes.length + ", Bytes already read: "
-							+ nextByte + ", Attempted to read: " + bytesToRead);
+							+ bytes.length + ", Bytes already read: " + nextByte
+							+ ", Attempted to read: " + bytesToRead);
 		}
 	}