/*

 * 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 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 {

        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 {

        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 {

        if (sink != null) {

            sink.receivedLast();

        }

    }

}