AppendableTraverser (Hazelcast Root 5.4.0-SNAPSHOT API)

java.lang.Object
- com.hazelcast.jet.core.AppendableTraverser<T>

Type Parameters:

T - item type

All Implemented Interfaces:

Traverser<T>
```
public class AppendableTraverser<T>
extends java.lang.Object
implements Traverser<T>
```
A traverser with an internal ArrayDeque. You can efficiently append(T) items to it that will be later traversed.
It's useful to be returned from a flat-mapping function when an item is flat-mapped to a small number of items:
```
     Traverser<Integer> at = new AppendableTraverser(2);
     Traverser<Integer> t = Traverser.over(10, 20)
         .flatMap(item -> {
             at.append(item);
             at.append(item + 1);
             return at;
         });
 
```
The t traverser above will output {10, 11, 20, 21}. This approach reduces the GC pressure by avoiding the allocation of a new traverser for each item that will traverse over just a few or even zero items.
See ResettableSingletonTraverser if you have at most one item to traverse.
Since:

Jet 3.0

Constructor Summary

Constructors
Constructor Description

AppendableTraverser(int initialCapacity)
Creates an appendable traverser.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`AppendableTraverser<T>`	`append(T item)`	Returns a traverser that will return all the items of this traverser, plus an additional item once this one returns `null`.
`boolean`	`isEmpty()`	Returns `true`, if the next call to `next()` will return `null`.
`T`	`next()`	Returns the next item, removing it from this traverser.

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

Methods inherited from interface com.hazelcast.jet.Traverser
dropWhile, filter, flatMap, map, onFirstNull, peek, prepend, takeWhile

- Constructor Detail
  - AppendableTraverser
```
public AppendableTraverser(int initialCapacity)
```
    Creates an appendable traverser.
- Method Detail
  - append
```
@Nonnull
public AppendableTraverser<T> append(@Nonnull
                                     T item)
```
    Returns a traverser that will return all the items of this traverser, plus an additional item once this one returns null. After that it continues forwarding the return values of this traverser. It is meant to be used on finite traversers.
    Default implementations always returns a new traverser instance. If you need to append multiple objects or use this method frequently, AppendableTraverser might be a better choice.
    
    Specified by:
    
    append in interface Traverser<T>
    
    Returns:
    
    this instance
  - next
```
public T next()
```
    Description copied from interface: Traverser
    
    Returns the next item, removing it from this traverser. If no item is available, returns null. If this traverser is null-terminated, getting a null means it's exhausted and will keep returning null forever. Otherwise, trying again later may produce one.
    
    Specified by:
    
    next in interface Traverser<T>
  - isEmpty
```
public boolean isEmpty()
```
    Returns true, if the next call to next() will return null.