AsyncEmptyPipe (org.pipecraft.pipes:pipes-core 0.9 API)

java.lang.Object
- org.pipecraft.pipes.async.AsyncPipe<T>
- - org.pipecraft.pipes.async.source.AsyncEmptyPipe<T>

Type Parameters:

T - The item data type

All Implemented Interfaces:

Closeable, AutoCloseable, BasePipe
```
public class AsyncEmptyPipe<T>
extends AsyncPipe<T>
```
An async source pipe returning no data. Similar to EmptyPipe, but for async pipes.

Author:

Eyal Schneider

- Nested Class Summary
  - Nested classes/interfaces inherited from class org.pipecraft.pipes.async.AsyncPipe
    AsyncPipe.Status
- Constructor Summary
  
  Constructors
  Constructor Description
  
  AsyncEmptyPipe()
- Method Summary
  
  All Methods Instance Methods Concrete Methods
  Modifier and Type Method Description
  
  float getProgress()
  
  void start()
  Performs pre-processing prior to item flow throw the pipe.
  - Methods inherited from class org.pipecraft.pipes.async.AsyncPipe
    close, getStatus, notifyDone, notifyError, notifyNext, setListener
  - Methods inherited from class java.lang.Object
    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AsyncEmptyPipe
```
public AsyncEmptyPipe()
```
- Method Detail
  - start
```
public void start()
           throws PipeException,
                  InterruptedException
```
    Description copied from interface: BasePipe
    
    Performs pre-processing prior to item flow throw the pipe. Implementations must call the same method for all their input pipes before accessing their items. This is typically done here.
    
    Throws:
    
    PipeException - In case of pipe errors in this pipe or somewhere up-stream.
    
    InterruptedException - In case that the operation has been interrupted by another thread.
  - getProgress
```
public float getProgress()
```
    Returns:
    
    The pipe flow progress, as a floating number between 0.0 and 1.0. Important implementation rules: 1) Calling this method before start() call is complete isn't allowed and has an undefined behavior. 2) Implementation should do best effort to provide an estimate of the progress this pipe has made (0.0 - 1.0) 3) When the pipe is fully consumed, getProgress() should return 1.0. 4) Results must be monotonous, i.e. results of consecutive calls may never be decreasing. 5) Thread safety: progress may be maintained by some thread/s but monitoring by other threads. Implementations must be thread safe.