New IOUtil class

src/zutil/io/BoundaryBufferedInputStream.java

@@ -0,0 +1,157 @@
+package zutil.io;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * TODO
+ * @author Ziver
+ *
+ */
+public class BoundaryBufferedInputStream extends FilterInputStream{
+	/** The size of the buffer in Byte */
+	public static final int DEFAULT_BUF_SIZE = 64*1024;
+
+	/** The Buffer */
+	protected byte buffer[];
+	/** The end of the buffer */
+	protected int buf_end = 0;
+	/** The position in the buffer */
+	protected int buf_pos = 0;
+	/** The boundary */
+	protected byte[] boundary;
+
+
+	/**
+	 * Creates a instance of this class with a default buffer size of 64K
+	 * 
+	 * @param 	in	is the InputStream that the buffer will use
+	 */
+	public BoundaryBufferedInputStream(InputStream in){
+		this(in, DEFAULT_BUF_SIZE);
+	}
+
+	/**
+	 * Creates a instance of this class
+	 * 
+	 * @param 	in			is the InputStream that the buffer will use
+	 * @param	buf_size	speifies the buffer size
+	 */
+	public BoundaryBufferedInputStream(InputStream in, int buf_size){
+		super(in);
+		reset();
+		buffer = new byte[buf_size];
+	}
+
+	/**
+	 * Moves the remaining data to the beginning of the 
+	 * buffer and then fills the buffer with data from 
+	 * the source stream to the buffer
+	 * 
+	 * @return the size of the buffer
+	 * @throws IOException
+	 */
+	protected int fillBuffer() throws IOException {
+		int leftover = buf_end - buf_pos;
+		System.arraycopy(buffer, buf_pos, buffer, 0, buf_end);
+		int n = super.read(buffer, leftover, buffer.length );
+		if(n+leftover >= 0) {
+			buf_end = leftover + n;
+			buf_pos = 0;
+		}
+		return n+leftover;
+	}
+
+	/**
+	 * Resets the buffer
+	 * 
+	 * @throws IOException
+	 */
+	public synchronized void reset(){
+		buf_end = 0;
+		buf_pos = 0;
+	}
+	
+	/**
+	 * @return the next byte in the buffer
+	 */
+	public final int read() throws IOException{
+		if(buf_pos >= buf_end) {
+			if(fillBuffer() < 0)
+				return -1;
+		}
+		if(buf_end == 0) {
+			return -1;
+		} else {
+			buf_pos++;
+			return buffer[buf_pos-1];
+		}
+	}
+
+	/**
+	 * Fills the given array with data from the buffer
+	 * 
+	 * @param 	b 	is the array that will be filled
+	 * @return 		the amount of bytes read or -1 if eof
+	 */
+	public int read(byte b[]) throws IOException {
+		return read(b, 0, b.length);
+	}
+
+	/**
+	 * Reads a given length of bytes from the buffer
+	 * 
+	 * @param 	b 		is the array that will be filled
+	 * @param 	off 	is the offset in the array
+	 * @param 	len 	is the amount to read
+	 * @return 			the amount of bytes read or -1 if eof
+	 */
+	public int read(byte b[], int off, int len) throws IOException {
+		if(buf_pos >= buf_end) {
+			if(fillBuffer() < 0)
+				return -1; // EOF
+		}
+		int leftover = buf_end - buf_pos;
+		// Copy from buffer
+		if(len <= leftover) {
+			System.arraycopy(buffer, buf_pos, b, off, len);
+			buf_pos += len;
+			return len;
+		}
+		
+		System.arraycopy(buffer, buf_pos, b, off, leftover);
+		int n = super.read(b, off+leftover, len-leftover );
+		fillBuffer();
+		if( n >= 0 )
+			return leftover + n;
+		return leftover;
+	}
+
+	/**
+     * @param	n 	the number of bytes to be skipped.
+     * @return		the actual number of bytes skipped.
+	 */
+	public long skip(long n) throws IOException {
+		int leftover = buf_end - buf_pos;
+		if(n > leftover){
+			buf_pos = buf_end;
+			return leftover;
+		}
+		return buf_pos += n;
+	}
+
+	/**
+	 * @return     an estimate of the number of bytes that can be read (or skipped
+	 *             over) from this input stream without blocking.
+	 * @exception  IOException  if an I/O error occurs.
+	 */
+	public int available() throws IOException {
+		return buf_end - buf_pos;
+	}
+
+	/**
+	 * Unimplemented
+	 */
+	public synchronized void mark(int readlimit) {}
+}

src/zutil/io/IOUtil.java

@@ -0,0 +1,36 @@
+package zutil.io;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+/**
+ * Utility class for streams and general IO stuff
+ * 
+ * @author Ziver
+ *
+ */
+public class IOUtil {
+
+	/**
+	 * Reads and returns the content of a file as a String.
+	 * Or use FileUtils.readFileToString(file);
+	 * 
+	 * @param 		stream 		is the file stream to read
+	 * @return 					The file content
+	 * @throws IOException
+	 */
+	public static String getContent(InputStream stream) throws IOException{
+		BufferedReader in = new BufferedReader(new InputStreamReader(stream));
+		StringBuffer ret = new StringBuffer();
+		int tmp;
+
+		while((tmp=in.read()) != -1){
+			ret.append((char)tmp);
+		}
+		
+		in.close();
+		return ret.toString();
+	}
+}

src/zutil/io/file/FileUtil.java

@@ -1,12 +1,10 @@
 package zutil.io.file;
 
 import java.io.BufferedInputStream;
-import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.InputStreamReader;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.util.HashMap;
@@ -14,6 +12,7 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.regex.Matcher;
 
+import zutil.io.IOUtil;
 import zutil.io.MultiPrintStream;
 
 /**
@@ -102,7 +101,7 @@ public class FileUtil {
 	 * @throws IOException
 	 */
 	public static String getFileContent(File file) throws IOException{
-		return getContent( new FileInputStream(file) );
+		return IOUtil.getContent( new FileInputStream(file) );
 	}
 	
 	/**
@@ -114,28 +113,7 @@ public class FileUtil {
 	 * @throws IOException
 	 */
 	public static String getContent(URL url) throws IOException{
-		return getContent( url.openStream() );
+		return IOUtil.getContent( url.openStream() );
-	}
-	
-	/**
-	 * Reads and returns the content of a file as a String.
-	 * Or use FileUtils.readFileToString(file);
-	 * 
-	 * @param 		stream 		is the file stream to read
-	 * @return 					The file content
-	 * @throws IOException
-	 */
-	public static String getContent(InputStream stream) throws IOException{
-		BufferedReader in = new BufferedReader(new InputStreamReader(stream));
-		StringBuffer ret = new StringBuffer();
-		int tmp;
-
-		while((tmp=in.read()) != -1){
-			ret.append((char)tmp);
-		}
-		
-		in.close();
-		return ret.toString();
 	}
 	
 	/**