Tank (Helidon 0.10.4 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>, java.lang.AutoCloseable, java.lang.Iterable<T>, java.util.Collection<T>, java.util.concurrent.BlockingQueue<T>, java.util.Queue<T>
```
public class Tank<T>
extends java.lang.Object
implements Valve<T>, java.util.concurrent.BlockingQueue<T>, java.lang.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(java.util.Collection<? extends T> c)`
`void`	`clear()`
`void`	`close()`
`boolean`	`contains(java.lang.Object o)`
`boolean`	`containsAll(java.util.Collection<?> c)`
`int`	`drainTo(java.util.Collection<? super T> c)`
`int`	`drainTo(java.util.Collection<? super T> c, int maxElements)`
`T`	`element()`
`void`	`forEach(java.util.function.Consumer<? super T> action)`
`void`	`handle(java.util.function.BiConsumer<T,Pausable> onData, java.util.function.Consumer<java.lang.Throwable> onError, java.lang.Runnable onComplete)`	Register data handlers (callbacks).
`boolean`	`isEmpty()`
`java.util.Iterator<T>`	`iterator()`
`boolean`	`offer(T t)`
`boolean`	`offer(T t, long timeout, java.util.concurrent.TimeUnit unit)`
`void`	`pause()`	Pause data chunks flow until `Pausable.resume()`.
`T`	`peek()`
`T`	`poll()`
`T`	`poll(long timeout, java.util.concurrent.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(java.lang.Object o)`
`boolean`	`removeAll(java.util.Collection<?> c)`
`boolean`	`removeIf(java.util.function.Predicate<? super T> filter)`
`void`	`resume()`	Resume data chunks flow after `Pausable.pause()`.
`boolean`	`retainAll(java.util.Collection<?> c)`
`int`	`size()`
`java.util.Spliterator<T>`	`spliterator()`
`T`	`take()`
`java.lang.Object[]`	`toArray()`
`<T1> T1[]`	`toArray(T1[] a)`
`void`	`whenDrain(java.lang.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(java.lang.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:
    
    java.lang.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(java.util.function.BiConsumer<T,Pausable> onData,
                   java.util.function.Consumer<java.lang.Throwable> onError,
                   java.lang.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 java.lang.AutoCloseable
  - add
```
public boolean add(T t)
```
    Specified by:
    
    add in interface java.util.concurrent.BlockingQueue<T>
    
    Specified by:
    
    add in interface java.util.Collection<T>
    
    Specified by:
    
    add in interface java.util.Queue<T>
  - addAll
```
public boolean addAll(java.util.Collection<? extends T> c)
```
    Specified by:
    
    addAll in interface java.util.Collection<T>
  - offer
```
public boolean offer(T t)
```
    Specified by:
    
    offer in interface java.util.concurrent.BlockingQueue<T>
    
    Specified by:
    
    offer in interface java.util.Queue<T>
  - put
```
public void put(T t)
         throws java.lang.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 java.util.concurrent.BlockingQueue<T>
    
    Throws:
    
    java.lang.InterruptedException
    
    java.lang.NullPointerException
    
    java.lang.IllegalArgumentException - if Tank is closed
  - offer
```
public boolean offer(T t,
                     long timeout,
                     java.util.concurrent.TimeUnit unit)
              throws java.lang.InterruptedException
```
    Specified by:
    
    offer in interface java.util.concurrent.BlockingQueue<T>
    
    Throws:
    
    java.lang.InterruptedException
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Collection<T>
  - poll
```
public T poll()
```
    Specified by:
    
    poll in interface java.util.Queue<T>
  - take
```
public T take()
       throws java.lang.InterruptedException
```
    Specified by:
    
    take in interface java.util.concurrent.BlockingQueue<T>
    
    Throws:
    
    java.lang.InterruptedException
  - poll
```
public T poll(long timeout,
              java.util.concurrent.TimeUnit unit)
       throws java.lang.InterruptedException
```
    Specified by:
    
    poll in interface java.util.concurrent.BlockingQueue<T>
    
    Throws:
    
    java.lang.InterruptedException
  - remove
```
public boolean remove(java.lang.Object o)
```
    Specified by:
    
    remove in interface java.util.concurrent.BlockingQueue<T>
    
    Specified by:
    
    remove in interface java.util.Collection<T>
  - drainTo
```
public int drainTo(java.util.Collection<? super T> c)
```
    Specified by:
    
    drainTo in interface java.util.concurrent.BlockingQueue<T>
  - drainTo
```
public int drainTo(java.util.Collection<? super T> c,
                   int maxElements)
```
    Specified by:
    
    drainTo in interface java.util.concurrent.BlockingQueue<T>
  - removeIf
```
public boolean removeIf(java.util.function.Predicate<? super T> filter)
```
    Specified by:
    
    removeIf in interface java.util.Collection<T>
  - removeAll
```
public boolean removeAll(java.util.Collection<?> c)
```
    Specified by:
    
    removeAll in interface java.util.Collection<T>
  - retainAll
```
public boolean retainAll(java.util.Collection<?> c)
```
    Specified by:
    
    retainAll in interface java.util.Collection<T>
  - remove
```
public T remove()
```
    Specified by:
    
    remove in interface java.util.Queue<T>
  - element
```
public T element()
```
    Specified by:
    
    element in interface java.util.Queue<T>
  - peek
```
public T peek()
```
    Specified by:
    
    peek in interface java.util.Queue<T>
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Collection<T>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Collection<T>
  - remainingCapacity
```
public int remainingCapacity()
```
    Specified by:
    
    remainingCapacity in interface java.util.concurrent.BlockingQueue<T>
  - containsAll
```
public boolean containsAll(java.util.Collection<?> c)
```
    Specified by:
    
    containsAll in interface java.util.Collection<T>
  - contains
```
public boolean contains(java.lang.Object o)
```
    Specified by:
    
    contains in interface java.util.concurrent.BlockingQueue<T>
    
    Specified by:
    
    contains in interface java.util.Collection<T>
  - toArray
```
public java.lang.Object[] toArray()
```
    Specified by:
    
    toArray in interface java.util.Collection<T>
  - toArray
```
public <T1> T1[] toArray(T1[] a)
```
    Specified by:
    
    toArray in interface java.util.Collection<T>
  - iterator
```
public java.util.Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface java.util.Collection<T>
    
    Specified by:
    
    iterator in interface java.lang.Iterable<T>
  - spliterator
```
public java.util.Spliterator<T> spliterator()
```
    Specified by:
    
    spliterator in interface java.util.Collection<T>
    
    Specified by:
    
    spliterator in interface java.lang.Iterable<T>
  - forEach
```
public void forEach(java.util.function.Consumer<? super T> action)
```
    Specified by:
    
    forEach in interface java.lang.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