Back to index...

	/*
	* Copyright (c) 1995, 2019, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package java.io;

	import java.io.*;

	/**
	* A piped output stream can be connected to a piped input stream
	* to create a communications pipe. The piped output stream is the
	* sending end of the pipe. Typically, data is written to a
	* {@code PipedOutputStream} object by one thread and data is
	* read from the connected {@code PipedInputStream} by some
	* other thread. Attempting to use both objects from a single thread
	* is not recommended as it may deadlock the thread.
	* The pipe is said to be <a id=BROKEN> <i>broken</i> </a> if a
	* thread that was reading data bytes from the connected piped input
	* stream is no longer alive.
	*
	* @author James Gosling
	* @see java.io.PipedInputStream
	* @since 1.0
	*/
	public class PipedOutputStream extends OutputStream {

	/* REMIND: identification of the read and write sides needs to be
	more sophisticated. Either using thread groups (but what about
	pipes within a thread?) or using finalization (but it may be a
	long time until the next GC). */
	private volatile PipedInputStream sink;

	/**
	* Creates a piped output stream connected to the specified piped
	* input stream. Data bytes written to this stream will then be
	* available as input from {@code snk}.
	*
	* @param snk The piped input stream to connect to.
	* @throws IOException if an I/O error occurs.
	*/
	public PipedOutputStream(PipedInputStream snk) throws IOException {
	connect(snk);
	}

	/**
	* Creates a piped output stream that is not yet connected to a
	* piped input stream. It must be connected to a piped input stream,
	* either by the receiver or the sender, before being used.
	*
	* @see java.io.PipedInputStream#connect(java.io.PipedOutputStream)
	* @see java.io.PipedOutputStream#connect(java.io.PipedInputStream)
	*/
	public PipedOutputStream() {
	}

	/**
	* Connects this piped output stream to a receiver. If this object
	* is already connected to some other piped input stream, an
	* {@code IOException} is thrown.
	* <p>
	* If {@code snk} is an unconnected piped input stream and
	* {@code src} is an unconnected piped output stream, they may
	* be connected by either the call:
	* <blockquote><pre>
	* src.connect(snk)</pre></blockquote>
	* or the call:
	* <blockquote><pre>
	* snk.connect(src)</pre></blockquote>
	* The two calls have the same effect.
	*
	* @param snk the piped input stream to connect to.
	* @throws IOException if an I/O error occurs.
	*/
	public synchronized void connect(PipedInputStream snk) throws IOException {
	if (snk == null) {
	throw new NullPointerException();
	} else if (sink != null \|\| snk.connected) {
	throw new IOException("Already connected");
	}
	sink = snk;
	snk.in = -1;
	snk.out = 0;
	snk.connected = true;
	}

	/**
	* Writes the specified {@code byte} to the piped output stream.
	* <p>
	* Implements the {@code write} method of {@code OutputStream}.
	*
	* @param b the {@code byte} to be written.
	* @throws IOException if the pipe is <a href=#BROKEN> broken</a>,
	* {@link #connect(java.io.PipedInputStream) unconnected},
	* closed, or if an I/O error occurs.
	*/
	public void write(int b) throws IOException {
	var sink = this.sink;
	if (sink == null) {
	throw new IOException("Pipe not connected");
	}
	sink.receive(b);
	}

	/**
	* Writes {@code len} bytes from the specified byte array
	* starting at offset {@code off} to this piped output stream.
	* This method blocks until all the bytes are written to the output
	* stream.
	*
	* @param b the data.
	* @param off the start offset in the data.
	* @param len the number of bytes to write.
	* @throws IOException if the pipe is <a href=#BROKEN> broken</a>,
	* {@link #connect(java.io.PipedInputStream) unconnected},
	* closed, or if an I/O error occurs.
	*/
	public void write(byte b[], int off, int len) throws IOException {
	var sink = this.sink;
	if (sink == null) {
	throw new IOException("Pipe not connected");
	} else if (b == null) {
	throw new NullPointerException();
	} else if ((off < 0) \|\| (off > b.length) \|\| (len < 0) \|\|
	((off + len) > b.length) \|\| ((off + len) < 0)) {
	throw new IndexOutOfBoundsException();
	} else if (len == 0) {
	return;
	}
	sink.receive(b, off, len);
	}

	/**
	* Flushes this output stream and forces any buffered output bytes
	* to be written out.
	* This will notify any readers that bytes are waiting in the pipe.
	*
	* @throws IOException if an I/O error occurs.
	*/
	public synchronized void flush() throws IOException {
	if (sink != null) {
	synchronized (sink) {
	sink.notifyAll();
	}
	}
	}

	/**
	* Closes this piped output stream and releases any system resources
	* associated with this stream. This stream may no longer be used for
	* writing bytes.
	*
	* @throws IOException if an I/O error occurs.
	*/
	public void close() throws IOException {
	var sink = this.sink;
	if (sink != null) {
	sink.receivedLast();
	}
	}
	}

Back to index...