Tank (Helidon 0.9.1 API)

java.lang.Object
- io.helidon.common.reactive.valve.Tank<T>

Type Parameters:

T - a type of items produced by Valve API

All Implemented Interfaces:

Pausable, Valve<T>, AutoCloseable, Iterable<T>, Collection<T>, BlockingQueue<T>, Queue<T>
```
public class Tank<T>
extends Object
implements Valve<T>, BlockingQueue<T>, AutoCloseable
```
Tank of events is a closeable FIFO queue with a limited size implementing Valve reactive API.

Constructor Summary

Constructors
Constructor Description

Tank(int capacity)
Creates new instance.

Constructors
Constructor	Description
`Tank(int capacity)`	Creates new instance.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`add(T t)`
`boolean`	`addAll(Collection<? extends T> c)`
`void`	`clear()`
`void`	`close()`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`int`	`drainTo(Collection<? super T> c)`
`int`	`drainTo(Collection<? super T> c, int maxElements)`
`T`	`element()`
`void`	`forEach(Consumer<? super T> action)`
`void`	`handle(BiConsumer<T,Pausable> onData, Consumer<Throwable> onError, Runnable onComplete)`	Register data handlers (callbacks).
`boolean`	`isEmpty()`
`Iterator<T>`	`iterator()`
`boolean`	`offer(T t)`
`boolean`	`offer(T t, long timeout, TimeUnit unit)`
`void`	`pause()`	Pause data chunks flow until `Pausable.resume()`.
`T`	`peek()`
`T`	`poll()`
`T`	`poll(long timeout, TimeUnit unit)`
`void`	`put(T t)`	Inserts the specified element at the tail of this queue, waiting for space to become available if the queue is full.
`int`	`remainingCapacity()`
`T`	`remove()`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> c)`
`boolean`	`removeIf(Predicate<? super T> filter)`
`void`	`resume()`	Resume data chunks flow after `Pausable.pause()`.
`boolean`	`retainAll(Collection<?> c)`
`int`	`size()`
`Spliterator<T>`	`spliterator()`
`T`	`take()`
`Object[]`	`toArray()`
`<T1> T1[]`	`toArray(T1[] a)`
`void`	`whenDrain(Runnable drainHandler)`	Provided handler is called a single time when internal capacity is maximally half full and instance is not closed.

Methods inherited from interface java.util.Collection
equals, hashCode, parallelStream, stream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface io.helidon.common.reactive.valve.Valve
collect, executeOn, filter, flatMap, handle, handle, handle, handle, handle, map, peek, toIterator, toPublisher

- Constructor Detail
  - Tank
```
public Tank(int capacity)
```
    Creates new instance.
    
    Parameters:
    
    capacity - the capacity of this queue
- Method Detail
  - whenDrain
```
public void whenDrain(Runnable drainHandler)
```
    Provided handler is called a single time when internal capacity is maximally half full and instance is not closed.
    
    Parameters:
    
    drainHandler - an handler of drain event
    
    Throws:
    
    NullPointerException - if drainHandler is null
  - pause
```
public void pause()
```
    Description copied from interface: Pausable
    
    Pause data chunks flow until Pausable.resume().
    
    Specified by:
    
    pause in interface Pausable
  - resume
```
public void resume()
```
    Description copied from interface: Pausable
    
    Resume data chunks flow after Pausable.pause().
    
    Specified by:
    
    resume in interface Pausable
  - handle
```
public void handle(BiConsumer<T,Pausable> onData,
                   Consumer<Throwable> onError,
                   Runnable onComplete)
```
    Description copied from interface: Valve
    
    Register data handlers (callbacks).
    
    Specified by:
    
    handle in interface Valve<T>
    
    Parameters:
    
    onData - a callback for data chunks and Pausable representing a faucet of this Valve.
    
    onError - a callback of errors or null
    
    onComplete - a callback for completion event or null
  - close
```
public void close()
```
    Specified by:
    
    close in interface AutoCloseable
  - add
```
public boolean add(T t)
```
    Specified by:
    
    add in interface BlockingQueue<T>
    
    Specified by:
    
    add in interface Collection<T>
    
    Specified by:
    
    add in interface Queue<T>
  - addAll
```
public boolean addAll(Collection<? extends T> c)
```
    Specified by:
    
    addAll in interface Collection<T>
  - offer
```
public boolean offer(T t)
```
    Specified by:
    
    offer in interface BlockingQueue<T>
    
    Specified by:
    
    offer in interface Queue<T>
  - put
```
public void put(T t)
         throws InterruptedException
```
    Inserts the specified element at the tail of this queue, waiting for space to become available if the queue is full.
    
    Specified by:
    
    put in interface BlockingQueue<T>
    
    Throws:
    
    InterruptedException
    
    NullPointerException
    
    IllegalArgumentException - if Tank is closed
  - offer
```
public boolean offer(T t,
                     long timeout,
                     TimeUnit unit)
              throws InterruptedException
```
    Specified by:
    
    offer in interface BlockingQueue<T>
    
    Throws:
    
    InterruptedException
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<T>
  - poll
```
public T poll()
```
    Specified by:
    
    poll in interface Queue<T>
  - take
```
public T take()
       throws InterruptedException
```
    Specified by:
    
    take in interface BlockingQueue<T>
    
    Throws:
    
    InterruptedException
  - poll
```
public T poll(long timeout,
              TimeUnit unit)
       throws InterruptedException
```
    Specified by:
    
    poll in interface BlockingQueue<T>
    
    Throws:
    
    InterruptedException
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface BlockingQueue<T>
    
    Specified by:
    
    remove in interface Collection<T>
  - drainTo
```
public int drainTo(Collection<? super T> c)
```
    Specified by:
    
    drainTo in interface BlockingQueue<T>
  - drainTo
```
public int drainTo(Collection<? super T> c,
                   int maxElements)
```
    Specified by:
    
    drainTo in interface BlockingQueue<T>
  - removeIf
```
public boolean removeIf(Predicate<? super T> filter)
```
    Specified by:
    
    removeIf in interface Collection<T>
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Specified by:
    
    removeAll in interface Collection<T>
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Specified by:
    
    retainAll in interface Collection<T>
  - remove
```
public T remove()
```
    Specified by:
    
    remove in interface Queue<T>
  - element
```
public T element()
```
    Specified by:
    
    element in interface Queue<T>
  - peek
```
public T peek()
```
    Specified by:
    
    peek in interface Queue<T>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Collection<T>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Collection<T>
  - remainingCapacity
```
public int remainingCapacity()
```
    Specified by:
    
    remainingCapacity in interface BlockingQueue<T>
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Specified by:
    
    containsAll in interface Collection<T>
  - contains
```
public boolean contains(Object o)
```
    Specified by:
    
    contains in interface BlockingQueue<T>
    
    Specified by:
    
    contains in interface Collection<T>
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<T>
  - toArray
```
public <T1> T1[] toArray(T1[] a)
```
    Specified by:
    
    toArray in interface Collection<T>
  - iterator
```
public Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface Collection<T>
    
    Specified by:
    
    iterator in interface Iterable<T>
  - spliterator
```
public Spliterator<T> spliterator()
```
    Specified by:
    
    spliterator in interface Collection<T>
    
    Specified by:
    
    spliterator in interface Iterable<T>
  - forEach
```
public void forEach(Consumer<? super T> action)
```
    Specified by:
    
    forEach in interface Iterable<T>

Class Tank<T>

Constructor Summary

Method Summary

Methods inherited from interface java.util.Collection

Methods inherited from class java.lang.Object

Methods inherited from interface io.helidon.common.reactive.valve.Valve

Constructor Detail

Tank

Method Detail

whenDrain

pause

resume

handle

close

add

addAll

offer

put

offer

clear

poll

take

poll

remove

drainTo

drainTo

removeIf

removeAll

retainAll

remove

element

peek

size

isEmpty

remainingCapacity

containsAll

contains

toArray

toArray

iterator

spliterator

forEach