summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorEike Stepper2007-08-28 03:18:36 (EDT)
committerEike Stepper2007-08-28 03:18:36 (EDT)
commit6db884b05fbfd12a688694bc7cd2cdae24c8e476 (patch)
tree411adf299203f08ced2644ca357cd01c8b6243ee
parent9d08d6d6d3de01045f7f210d67561f587545ec26 (diff)
downloadcdo-6db884b05fbfd12a688694bc7cd2cdae24c8e476.zip
cdo-6db884b05fbfd12a688694bc7cd2cdae24c8e476.tar.gz
cdo-6db884b05fbfd12a688694bc7cd2cdae24c8e476.tar.bz2
*** empty log message ***
-rw-r--r--plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/io/DelegatingInputStream.java192
-rw-r--r--plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/io/DelegatingOutputStream.java115
2 files changed, 307 insertions, 0 deletions
diff --git a/plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/io/DelegatingInputStream.java b/plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/io/DelegatingInputStream.java
new file mode 100644
index 0000000..54b38b0
--- /dev/null
+++ b/plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/io/DelegatingInputStream.java
@@ -0,0 +1,192 @@
+package org.eclipse.net4j.util.io;
+
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * A <code>DelegatingInputStream</code> contains some other input stream,
+ * which it uses as its basic source of data, possibly transforming the data
+ * along the way or providing additional functionality. The class
+ * <code>DelegatingInputStream</code> itself simply overrides all (see note
+ * below) methods of <code>InputStream</code> with versions that pass all
+ * requests to the contained input stream. Subclasses of
+ * <code>DelegatingInputStream</code> may further override some of these
+ * methods and may also provide additional methods and fields.
+ * <p>
+ * <b>Note:</b> The only difference to {@link FilterInputStream} is that
+ * <code>DelegatingInputStream</code> does <b>not</b> override
+ * {@link #read(byte[])} or {@link #read(byte[], int, int)} but rather exposes
+ * the original implementations of <code>InputStream</code> which call
+ * {@link #read()} instead of their delegate counterparts.
+ *
+ * @author Eike Stepper
+ */
+public class DelegatingInputStream extends InputStream
+{
+ /**
+ * The input stream to be filtered.
+ */
+ protected volatile InputStream in;
+
+ /**
+ * Creates a <code>DelegatingInputStream</code> by assigning the argument
+ * <code>in</code> to the field <code>this.in</code> so as to remember it
+ * for later use.
+ *
+ * @param in
+ * the underlying input stream, or <code>null</code> if this
+ * instance is to be created without an underlying stream.
+ */
+ protected DelegatingInputStream(InputStream in)
+ {
+ this.in = in;
+ }
+
+ public InputStream getDelegate()
+ {
+ return in;
+ }
+
+ /**
+ * Reads the next byte of data from this input stream. The value byte is
+ * returned as an <code>int</code> in the range <code>0</code> to
+ * <code>255</code>. If no byte is available because the end of the stream
+ * has been reached, the value <code>-1</code> is returned. This method
+ * blocks until input data is available, the end of the stream is detected, or
+ * an exception is thrown.
+ * <p>
+ * This method simply performs <code>in.read()</code> and returns the
+ * result.
+ *
+ * @return the next byte of data, or <code>-1</code> if the end of the
+ * stream is reached.
+ * @exception IOException
+ * if an I/O error occurs.
+ * @see DelegatingInputStream#in
+ */
+ @Override
+ public int read() throws IOException
+ {
+ return in.read();
+ }
+
+ /**
+ * Skips over and discards <code>n</code> bytes of data from the input
+ * stream. The <code>skip</code> method may, for a variety of reasons, end
+ * up skipping over some smaller number of bytes, possibly <code>0</code>.
+ * The actual number of bytes skipped is returned.
+ * <p>
+ * This method simply performs <code>in.skip(n)</code>.
+ *
+ * @param n
+ * the number of bytes to be skipped.
+ * @return the actual number of bytes skipped.
+ * @exception IOException
+ * if an I/O error occurs.
+ */
+ @Override
+ public long skip(long n) throws IOException
+ {
+ return in.skip(n);
+ }
+
+ /**
+ * Returns the number of bytes that can be read from this input stream without
+ * blocking.
+ * <p>
+ * This method simply performs <code>in.available()</code> and returns the
+ * result.
+ *
+ * @return the number of bytes that can be read from the input stream without
+ * blocking.
+ * @exception IOException
+ * if an I/O error occurs.
+ * @see DelegatingInputStream#in
+ */
+ @Override
+ public int available() throws IOException
+ {
+ return in.available();
+ }
+
+ /**
+ * Closes this input stream and releases any system resources associated with
+ * the stream. This method simply performs <code>in.close()</code>.
+ *
+ * @exception IOException
+ * if an I/O error occurs.
+ * @see DelegatingInputStream#in
+ */
+ @Override
+ public void close() throws IOException
+ {
+ in.close();
+ }
+
+ /**
+ * Marks the current position in this input stream. A subsequent call to the
+ * <code>reset</code> method repositions this stream at the last marked
+ * position so that subsequent reads re-read the same bytes.
+ * <p>
+ * The <code>readlimit</code> argument tells this input stream to allow that
+ * many bytes to be read before the mark position gets invalidated.
+ * <p>
+ * This method simply performs <code>in.mark(readlimit)</code>.
+ *
+ * @param readlimit
+ * the maximum limit of bytes that can be read before the mark
+ * position becomes invalid.
+ * @see DelegatingInputStream#in
+ * @see DelegatingInputStream#reset()
+ */
+ @Override
+ public synchronized void mark(int readlimit)
+ {
+ in.mark(readlimit);
+ }
+
+ /**
+ * Repositions this stream to the position at the time the <code>mark</code>
+ * method was last called on this input stream.
+ * <p>
+ * This method simply performs <code>in.reset()</code>.
+ * <p>
+ * Stream marks are intended to be used in situations where you need to read
+ * ahead a little to see what's in the stream. Often this is most easily done
+ * by invoking some general parser. If the stream is of the type handled by
+ * the parse, it just chugs along happily. If the stream is not of that type,
+ * the parser should toss an exception when it fails. If this happens within
+ * readlimit bytes, it allows the outer code to reset the stream and try
+ * another parser.
+ *
+ * @exception IOException
+ * if the stream has not been marked or if the mark has been
+ * invalidated.
+ * @see DelegatingInputStream#in
+ * @see DelegatingInputStream#mark(int)
+ */
+ @Override
+ public synchronized void reset() throws IOException
+ {
+ in.reset();
+ }
+
+ /**
+ * Tests if this input stream supports the <code>mark</code> and
+ * <code>reset</code> methods. This method simply performs
+ * <code>in.markSupported()</code>.
+ *
+ * @return <code>true</code> if this stream type supports the
+ * <code>mark</code> and <code>reset</code> method;
+ * <code>false</code> otherwise.
+ * @see DelegatingInputStream#in
+ * @see java.io.InputStream#mark(int)
+ * @see java.io.InputStream#reset()
+ */
+ @Override
+ public boolean markSupported()
+ {
+ return in.markSupported();
+ }
+}
diff --git a/plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/io/DelegatingOutputStream.java b/plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/io/DelegatingOutputStream.java
new file mode 100644
index 0000000..1f7dcb4
--- /dev/null
+++ b/plugins/org.eclipse.net4j.util/src/org/eclipse/net4j/util/io/DelegatingOutputStream.java
@@ -0,0 +1,115 @@
+package org.eclipse.net4j.util.io;
+
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+
+/**
+ * This class is the superclass of all classes that filter output streams. These
+ * streams sit on top of an already existing output stream (the <i>underlying</i>
+ * output stream) which it uses as its basic sink of data, but possibly
+ * transforming the data along the way or providing additional functionality.
+ * <p>
+ * The class <code>DelegatingOutputStream</code> itself simply overrides all
+ * methods of <code>OutputStream</code> with versions that pass all requests
+ * to the underlying output stream. Subclasses of
+ * <code>DelegatingOutputStream</code> may further override some of these
+ * methods as well as provide additional methods and fields.
+ * <p>
+ * <b>Note:</b> The only difference to {@link FilterOutputStream} is that
+ * <code>DelegatingOutputStream</code> does <b>not</b> override
+ * {@link #write(byte[])} or {@link #write(byte[], int, int)} but rather exposes
+ * the original implementations of <code>InputStream</code> which call
+ * {@link #write(int)} instead of their delegate counterparts.
+ *
+ * @author Eike Stepper
+ */
+public class DelegatingOutputStream extends OutputStream
+{
+ /**
+ * The underlying output stream to be filtered.
+ */
+ protected OutputStream out;
+
+ /**
+ * Creates an output stream filter built on top of the specified underlying
+ * output stream.
+ *
+ * @param out
+ * the underlying output stream to be assigned to the field
+ * <tt>this.out</tt> for later use, or <code>null</code> if this
+ * instance is to be created without an underlying stream.
+ */
+ public DelegatingOutputStream(OutputStream out)
+ {
+ this.out = out;
+ }
+
+ public OutputStream getDelegate()
+ {
+ return out;
+ }
+
+ /**
+ * Writes the specified <code>byte</code> to this output stream.
+ * <p>
+ * The <code>write</code> method of <code>DelegatingOutputStream</code>
+ * calls the <code>write</code> method of its underlying output stream, that
+ * is, it performs <tt>out.write(b)</tt>.
+ * <p>
+ * Implements the abstract <tt>write</tt> method of <tt>OutputStream</tt>.
+ *
+ * @param b
+ * the <code>byte</code>.
+ * @exception IOException
+ * if an I/O error occurs.
+ */
+ @Override
+ public void write(int b) throws IOException
+ {
+ out.write(b);
+ }
+
+ /**
+ * Flushes this output stream and forces any buffered output bytes to be
+ * written out to the stream.
+ * <p>
+ * The <code>flush</code> method of <code>DelegatingOutputStream</code>
+ * calls the <code>flush</code> method of its underlying output stream.
+ *
+ * @exception IOException
+ * if an I/O error occurs.
+ * @see DelegatingOutputStream#out
+ */
+ @Override
+ public void flush() throws IOException
+ {
+ out.flush();
+ }
+
+ /**
+ * Closes this output stream and releases any system resources associated with
+ * the stream.
+ * <p>
+ * The <code>close</code> method of <code>DelegatingOutputStream</code>
+ * calls its <code>flush</code> method, and then calls the
+ * <code>close</code> method of its underlying output stream.
+ *
+ * @exception IOException
+ * if an I/O error occurs.
+ * @see DelegatingOutputStream#flush()
+ * @see DelegatingOutputStream#out
+ */
+ @Override
+ public void close() throws IOException
+ {
+ try
+ {
+ flush();
+ }
+ catch (IOException ignored)
+ {
+ }
+ out.close();
+ }
+}