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

All Implemented Interfaces:

Consumer<E>, CapacityCarrying, CapacityExtendable, ExtendedCollection<E>, OptimizableCollection, Sized, XAddingCollection<E>, Synchronized, ThreadSafe
```
public final class LockedAdder<E>
extends Object
implements XAddingCollection<E>, Synchronized
```

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

Constructor Summary

Constructors
Constructor Description

LockedAdder(XAddingCollection<E> collection)

LockedAdder(XAddingCollection<E> collection, Object lock)

Method Summary

Modifier and Type	Method	Description
`void`	`accept(E e)`
`boolean`	`add(E e)`
`LockedAdder<E>`	`addAll(E... elements)`
`LockedAdder<E>`	`addAll(E[] elements, int offset, int length)`
`LockedAdder<E>`	`addAll(XGettingCollection<? extends E> elements)`
`long`	`currentCapacity()`	Returns the current amount of elements this instance can hold before a storage rebuild becomes necessary.
`LockedAdder<E>`	`ensureCapacity(long minimalCapacity)`
`LockedAdder<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()`
`boolean`	`isEmpty()`
`boolean`	`isFull()`	Returns true if the current capacity cannot be increased any more.
`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()`
`long`	`optimize()`	Optimizes the internal storage of this collection and returns the storage size of the collection after the process is complete.
`long`	`remainingCapacity()`	Returns the amount of elements this carrier instance can collect before reaching its maximimum capacity.
`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.interfaces.CapacityExtendable
currentFreeCapacity

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

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

- Constructor Detail
  - LockedAdder
```
public LockedAdder(XAddingCollection<E> collection)
```
  - LockedAdder
```
public LockedAdder(XAddingCollection<E> collection,
                   Object lock)
```
- Method Detail
  - nullAdd
```
public final boolean nullAdd()
```
    Specified by:
    
    nullAdd in interface XAddingCollection<E>
  - add
```
public final boolean add(E e)
```
    Specified by:
    
    add in interface XAddingCollection<E>
  - addAll
```
@SafeVarargs
public final LockedAdder<E> addAll(E... elements)
```
    Specified by:
    
    addAll in interface XAddingCollection<E>
  - addAll
```
public final LockedAdder<E> addAll(E[] elements,
                                   int offset,
                                   int length)
```
    Specified by:
    
    addAll in interface XAddingCollection<E>
  - addAll
```
public final LockedAdder<E> addAll(XGettingCollection<? extends E> elements)
```
    Specified by:
    
    addAll in interface XAddingCollection<E>
  - accept
```
public final void accept(E e)
```
    Specified by:
    
    accept in interface Consumer<E>
    
    Specified by:
    
    accept in interface XAddingCollection<E>
  - ensureFreeCapacity
```
public final LockedAdder<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
  - ensureCapacity
```
public final LockedAdder<E> ensureCapacity(long minimalCapacity)
```
    Specified by:
    
    ensureCapacity in interface CapacityExtendable
  - currentCapacity
```
public final 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 final 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 final boolean isFull()
```
    Description copied from interface: CapacityCarrying
    
    Returns true if the current capacity cannot be increased any more.
    
    Specified by:
    
    isFull in interface CapacityCarrying
  - remainingCapacity
```
public final long remainingCapacity()
```
    Description copied from interface: CapacityCarrying
    
    Returns the amount of elements this carrier instance can collect before reaching its maximimum capacity.
    
    Specified by:
    
    remainingCapacity in interface CapacityCarrying
  - optimize
```
public final 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 final boolean hasVolatileElements()
```
    Specified by:
    
    hasVolatileElements in interface ExtendedCollection<E>
  - nullAllowed
```
public final boolean nullAllowed()
```
    Specified by:
    
    nullAllowed in interface ExtendedCollection<E>
  - isEmpty
```
public final boolean isEmpty()
                      throws UnsupportedOperationException
```
    Specified by:
    
    isEmpty in interface Sized
    
    Throws:
    
    UnsupportedOperationException
  - size
```
public final long size()
                throws UnsupportedOperationException
```
    Specified by:
    
    size in interface Sized
    
    Throws:
    
    UnsupportedOperationException

Constructor	Description
`LockedAdder(XAddingCollection<E> collection)`
`LockedAdder(XAddingCollection<E> collection, Object lock)`

Class LockedAdder<E>

Nested Class Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.function.Consumer

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

Constructor Detail

LockedAdder

LockedAdder

Method Detail

nullAdd

add

addAll

addAll

addAll

accept

ensureFreeCapacity

ensureCapacity

currentCapacity

maximumCapacity

isFull

remainingCapacity

optimize

hasVolatileElements

nullAllowed

isEmpty

size