/*

 * 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

 * particular file as subject to the "Classpath" exception as provided

 *

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

 *

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea with assistance from members of JCP JSR-166

 * Expert Group and released to the public domain, as explained at

 * http://creativecommons.org/licenses/publicdomain

 */

package java.util.concurrent;

/**

 * A {@link BlockingQueue} in which producers may wait for consumers

 * to receive elements.  A {@code TransferQueue} may be useful for

 * example in message passing applications in which producers

 * sometimes (using method {@link #transfer}) await receipt of

 * elements by consumers invoking {@code take} or {@code poll}, while

 * at other times enqueue elements (via method {@code put}) without

 * waiting for receipt.

 * {@linkplain #tryTransfer(Object) Non-blocking} and

 * {@linkplain #tryTransfer(Object,long,TimeUnit) time-out} versions of

 * {@code tryTransfer} are also available.

 * A {@code TransferQueue} may also be queried, via {@link

 * #hasWaitingConsumer}, whether there are any threads waiting for

 * items, which is a converse analogy to a {@code peek} operation.

 *

 * <p>Like other blocking queues, a {@code TransferQueue} may be

 * capacity bounded.  If so, an attempted transfer operation may

 * initially block waiting for available space, and/or subsequently

 * block waiting for reception by a consumer.  Note that in a queue

 * with zero capacity, such as {@link SynchronousQueue}, {@code put}

 * and {@code transfer} are effectively synonymous.

 *

 * <p>This interface is a member of the

 * <a href="{@docRoot}/../technotes/guides/collections/index.html">

 * Java Collections Framework</a>.

 *

 * @since 1.7

 * @author Doug Lea

 * @param <E> the type of elements held in this collection

 */

public interface TransferQueue<E> extends BlockingQueue<E> {

    /**

     * Transfers the element to a waiting consumer immediately, if possible.

     *

     * <p>More precisely, transfers the specified element immediately

     * if there exists a consumer already waiting to receive it (in

     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),

     * otherwise returning {@code false} without enqueuing the element.

     *

     * @param e the element to transfer

     * @return {@code true} if the element was transferred, else

     *         {@code false}

     * @throws ClassCastException if the class of the specified element

     *         prevents it from being added to this queue

     * @throws NullPointerException if the specified element is null

     * @throws IllegalArgumentException if some property of the specified

     *         element prevents it from being added to this queue

     */

    boolean tryTransfer(E e);

    /**

     * Transfers the element to a consumer, waiting if necessary to do so.

     *

     * <p>More precisely, transfers the specified element immediately

     * if there exists a consumer already waiting to receive it (in

     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),

     * else waits until the element is received by a consumer.

     *

     * @param e the element to transfer

     * @throws InterruptedException if interrupted while waiting,

     *         in which case the element is not left enqueued

     * @throws ClassCastException if the class of the specified element

     *         prevents it from being added to this queue

     * @throws NullPointerException if the specified element is null

     * @throws IllegalArgumentException if some property of the specified

     *         element prevents it from being added to this queue

     */

    void transfer(E e) throws InterruptedException;

    /**

     * Transfers the element to a consumer if it is possible to do so

     * before the timeout elapses.

     *

     * <p>More precisely, transfers the specified element immediately

     * if there exists a consumer already waiting to receive it (in

     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),

     * else waits until the element is received by a consumer,

     * returning {@code false} if the specified wait time elapses

     * before the element can be transferred.

     *

     * @param e the element to transfer

     * @param timeout how long to wait before giving up, in units of

     *        {@code unit}

     * @param unit a {@code TimeUnit} determining how to interpret the

     *        {@code timeout} parameter

     * @return {@code true} if successful, or {@code false} if

     *         the specified waiting time elapses before completion,

     *         in which case the element is not left enqueued

     * @throws InterruptedException if interrupted while waiting,

     *         in which case the element is not left enqueued

     * @throws ClassCastException if the class of the specified element

     *         prevents it from being added to this queue

     * @throws NullPointerException if the specified element is null

     * @throws IllegalArgumentException if some property of the specified

     *         element prevents it from being added to this queue

     */

    boolean tryTransfer(E e, long timeout, TimeUnit unit)

        throws InterruptedException;

    /**

     * Returns {@code true} if there is at least one consumer waiting

     * to receive an element via {@link #take} or

     * timed {@link #poll(long,TimeUnit) poll}.

     * The return value represents a momentary state of affairs.

     *

     * @return {@code true} if there is at least one waiting consumer

     */

    boolean hasWaitingConsumer();

    /**

     * Returns an estimate of the number of consumers waiting to

     * receive elements via {@link #take} or timed

     * {@link #poll(long,TimeUnit) poll}.  The return value is an

     * approximation of a momentary state of affairs, that may be

     * inaccurate if consumers have completed or given up waiting.

     * The value may be useful for monitoring and heuristics, but

     * not for synchronization control.  Implementations of this

     * method are likely to be noticeably slower than those for

     * {@link #hasWaitingConsumer}.

     *

     * @return the number of consumers waiting to receive elements

     */

    int getWaitingConsumerCount();

}