Collector (MicroStream API)

java.lang.Object
- one.microstream.collections.Collector<E>

All Implemented Interfaces:

Consumer<E>, CapacityCarrying, CapacityExtendable, ExtendedCollection<E>, OptimizableCollection, Sized, XAddingCollection<E>, XPuttingCollection<E>
```
public final class Collector<E>
extends Object
implements XPuttingCollection<E>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface one.microstream.collections.types.XPuttingCollection
  XPuttingCollection.Creator<E>

Constructor Summary

Constructors
Constructor and Description

Collector(XPuttingCollection<E> collection)

Constructors
Constructor and Description
`Collector(XPuttingCollection<E> collection)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`accept(E e)`
`boolean`	`add(E e)` Adds the passed element.
`Collector<E>`	`addAll(E... elements)`
`Collector<E>`	`addAll(E[] elements, int offset, int length)`
`Collector<E>`	`addAll(XGettingCollection<? extends E> elements)`
`long`	`currentCapacity()` Returns the current amount of elements this instance can hold before a storage rebuild becomes necessary.
`Collector<E>`	`ensureCapacity(long minimalCapacity)`
`Collector<E>`	`ensureFreeCapacity(long minimalFreeCapacity)` Ensures that the next minimalFreeCapacity elements can be actually added in a fast way, meaning for example no internal storage rebuild will be necessary.
`boolean`	`hasVolatileElements()` Tells if this collection contains volatile elements. An element is volatile, if it can become no longer reachable by the collection without being removed from the collection.
`boolean`	`isEmpty()`
`boolean`	`isFull()`
`long`	`maximumCapacity()` Returns the maximum amount of elements this carrier instance can contain. The actual value may be depend on the configuration of the concrete instance or may depend only on the implementation of the carrier (meaning it is constant for all instances of the implementation, e.g.
`boolean`	`nullAdd()`
`boolean`	`nullAllowed()` Defines if null-elements are allowed inside the collection or not.
`boolean`	`nullPut()`
`long`	`optimize()` Optimizes the internal storage of this collection and returns the storage size of the collection after the process is complete.
`boolean`	`put(E element)` Adds the specified element to this collection if it is not already present (optional operation).
`Collector<E>`	`putAll(E... elements)` Adds the specified elements to this collection if it is not already present (optional operation).
`Collector<E>`	`putAll(E[] elements, int offset, int length)` Adds the specified elements to this collection if it is not already present (optional operation). Only the elements with indizes from the srcStartIndex to the srcStartIndex+srcLength are put in the collection.
`Collector<E>`	`putAll(XGettingCollection<? extends E> elements)` Adds the specified elements to this collection if it is not already present (optional operation).
`long`	`remainingCapacity()`
`long`	`size()`

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

Methods inherited from interface one.microstream.collections.types.XAddingCollection
collector

Methods inherited from interface one.microstream.collections.interfaces.CapacityExtendable
currentFreeCapacity

Methods inherited from interface java.util.function.Consumer
andThen

- Constructor Detail
  - Collector
```
public Collector(XPuttingCollection<E> collection)
```
- Method Detail
  - nullAdd
```
public boolean nullAdd()
```
    Specified by:
    
    nullAdd in interface XAddingCollection<E>
  - add
```
public boolean add(E e)
```
    Description copied from interface: XAddingCollection
    
    Adds the passed element.
    
    Specified by:
    
    add in interface XAddingCollection<E>
    
    Parameters:
    
    e - to add
    
    Returns:
    
    true if element was added; false if not
  - addAll
```
public Collector<E> addAll(E... elements)
```
    Specified by:
    
    addAll in interface XAddingCollection<E>
  - addAll
```
public Collector<E> addAll(E[] elements,
                           int offset,
                           int length)
```
    Specified by:
    
    addAll in interface XAddingCollection<E>
  - addAll
```
public Collector<E> addAll(XGettingCollection<? extends E> elements)
```
    Specified by:
    
    addAll in interface XAddingCollection<E>
  - nullPut
```
public boolean nullPut()
```
    Specified by:
    
    nullPut in interface XPuttingCollection<E>
  - accept
```
public void accept(E e)
```
    Specified by:
    
    accept in interface Consumer<E>
    
    Specified by:
    
    accept in interface XAddingCollection<E>
  - put
```
public boolean put(E element)
```
    Description copied from interface: XPuttingCollection
    
    Adds the specified element to this collection if it is not already present (optional operation).
    
    Specified by:
    
    put in interface XPuttingCollection<E>
    
    Parameters:
    
    element - to add
    
    Returns:
    
    true if this collection did not already contain the specified element
  - putAll
```
public Collector<E> putAll(E... elements)
```
    Description copied from interface: XPuttingCollection
    
    Adds the specified elements to this collection if it is not already present (optional operation).
    
    Specified by:
    
    putAll in interface XPuttingCollection<E>
    
    Parameters:
    
    elements - to add
    
    Returns:
    
    this
  - putAll
```
public Collector<E> putAll(E[] elements,
                           int offset,
                           int length)
```
    Description copied from interface: XPuttingCollection
    
    Adds the specified elements to this collection if it is not already present (optional operation).
    Only the elements with indizes from the srcStartIndex to the srcStartIndex+srcLength are put in the collection.
    
    Specified by:
    
    putAll in interface XPuttingCollection<E>
    
    Parameters:
    
    elements - to add
    
    offset - start index of elements-array to add to collection
    
    length - length of elements-array to add to collection
    
    Returns:
    
    this
  - putAll
```
public Collector<E> putAll(XGettingCollection<? extends E> elements)
```
    Description copied from interface: XPuttingCollection
    
    Adds the specified elements to this collection if it is not already present (optional operation).
    
    Specified by:
    
    putAll in interface XPuttingCollection<E>
    
    Parameters:
    
    elements - to add
    
    Returns:
    
    this
  - ensureCapacity
```
public Collector<E> ensureCapacity(long minimalCapacity)
```
    Specified by:
    
    ensureCapacity in interface CapacityExtendable
  - currentCapacity
```
public long currentCapacity()
```
    Description copied from interface: CapacityExtendable
    
    Returns the current amount of elements this instance can hold before a storage rebuild becomes necessary.
    For carrier implementations that don't have a concept of storage rebuilding (like linked list for example) this method returns the same value as CapacityCarrying.maximumCapacity().
    
    Specified by:
    
    currentCapacity in interface CapacityExtendable
    
    Returns:
    
    the current capacity of this instance before a rebuild is required.
  - maximumCapacity
```
public long maximumCapacity()
```
    Description copied from interface: CapacityCarrying
    
    Returns the maximum amount of elements this carrier instance can contain.
    The actual value may be depend on the configuration of the concrete instance or may depend only on the implementation of the carrier (meaning it is constant for all instances of the implementation, e.g. Integer.MAX_VALUE)
    
    Specified by:
    
    maximumCapacity in interface CapacityCarrying
    
    Returns:
    
    the maximum amount of elements this carrier instance can contain.
  - isFull
```
public boolean isFull()
```
    Specified by:
    
    isFull in interface CapacityCarrying
    
    Returns:
    
    true if the current capacity cannot be increased any more.
  - remainingCapacity
```
public long remainingCapacity()
```
    Specified by:
    
    remainingCapacity in interface CapacityCarrying
    
    Returns:
    
    the amount of elements this carrier instance can collect before reaching its maximimum capacity.
  - ensureFreeCapacity
```
public Collector<E> ensureFreeCapacity(long minimalFreeCapacity)
```
    Description copied from interface: CapacityExtendable
    
    Ensures that the next minimalFreeCapacity elements can be actually added in a fast way, meaning for example no internal storage rebuild will be necessary.
    
    Specified by:
    
    ensureFreeCapacity in interface CapacityExtendable
    
    Parameters:
    
    minimalFreeCapacity - the capacity to ensure
    
    Returns:
    
    this
  - optimize
```
public long optimize()
```
    Description copied from interface: OptimizableCollection
    
    Optimizes the internal storage of this collection and returns the storage size of the collection after the process is complete.
    
    Specified by:
    
    optimize in interface OptimizableCollection
    
    Returns:
    
    the storage size of the collection after the optimzation.
  - hasVolatileElements
```
public boolean hasVolatileElements()
```
    Description copied from interface: ExtendedCollection
    
    Tells if this collection contains volatile elements.
    An element is volatile, if it can become no longer reachable by the collection without being removed from the collection. Examples are WeakReference of SoftReference or implementations of collection entries that remove the element contained in an entry by some means outside the collection.
    Note that WeakReference instances that are added to a a simple (non-volatile) implementation of a collection do not make the collection volatile, as the elements themselves (the reference instances) are still strongly referenced.
    
    Specified by:
    
    hasVolatileElements in interface ExtendedCollection<E>
    
    Returns:
    
    true if the collection contains volatile elements.
  - nullAllowed
```
public boolean nullAllowed()
```
    Description copied from interface: ExtendedCollection
    
    Defines if null-elements are allowed inside the collection or not.
    
    Specified by:
    
    nullAllowed in interface ExtendedCollection<E>
    
    Returns:
    
    true if null is allowed inside the collection; false if not
  - isEmpty
```
public boolean isEmpty()
                throws UnsupportedOperationException
```
    Specified by:
    
    isEmpty in interface Sized
    
    Throws:
    
    UnsupportedOperationException
  - size
```
public long size()
          throws UnsupportedOperationException
```
    Specified by:
    
    size in interface Sized
    
    Throws:
    
    UnsupportedOperationException

Class Collector<E>

Nested Class Summary

Nested classes/interfaces inherited from interface one.microstream.collections.types.XPuttingCollection

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface one.microstream.collections.types.XAddingCollection

Methods inherited from interface one.microstream.collections.interfaces.CapacityExtendable

Methods inherited from interface java.util.function.Consumer

Constructor Detail

Collector

Method Detail

nullAdd

add

addAll

addAll

addAll

nullPut

accept

put

putAll

putAll

putAll

ensureCapacity

currentCapacity

maximumCapacity

isFull

remainingCapacity

ensureFreeCapacity

optimize

hasVolatileElements

nullAllowed

isEmpty

size