SnapshotableDeque (Sodeac Common 0.5.4 API)

java.lang.Object
- org.sodeac.common.snapdeque.SnapshotableDeque<E>

Type Parameters:

E - the type of elements in deque

All Implemented Interfaces:

AutoCloseable, Iterable<E>, Collection<E>, Deque<E>, Queue<E>
```
public class SnapshotableDeque<E>
extends Object
implements AutoCloseable, Deque<E>
```
A threadsafe and snapshotable Deque. Iterating through deque requires creating a DequeSnapshot.

Since:

1.0

Version:

1.0

Author:

Sebastian Palarus

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`SnapshotableDeque.Bollard` Internal helper class to reference begin or end of branch.
`protected static class`	`SnapshotableDeque.ClearCompleteForwardBranch<E>` Internal helper class
`protected static class`	`SnapshotableDeque.Eyebolt<E>` Internal helper class to reference begin or end of branch.
`static class`	`SnapshotableDeque.LinkMode`
`protected static class`	`SnapshotableDeque.SnapshotVersion<E>` Internal helper class to manage versions

Field Summary

Fields
Modifier and Type	Field and Description
`protected SnapshotableDeque.Bollard`	`begin`
`protected long`	`capacity`
`protected SnapshotableDeque.Bollard`	`end`
`protected LinkedList<INodeEventHandler<E>>`	`eventHandlerList`
`protected SnapshotableDeque.SnapshotVersion<E>`	`modificationVersion`
`protected long`	`nodeSize`
`protected LinkedList<DequeNode.Link<E>>`	`obsoleteList`
`protected Set<SnapshotableDeque.SnapshotVersion<E>>`	`openSnapshotVersionList`
`protected ReentrantReadWriteLock.ReadLock`	`readLock`
`protected ReentrantReadWriteLock`	`rwLock`
`protected SnapshotableDeque.SnapshotVersion<E>`	`snapshotVersion`
`protected UUID`	`uuid`
`protected ReentrantReadWriteLock.WriteLock`	`writeLock`

Constructor Summary

Constructors
Constructor and Description
`SnapshotableDeque()` Constructor to create a SnapshotableDeque .
`SnapshotableDeque(long capacity)` Constructor to create a SnapshotableDeque with specified capacity .

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(E e)`
`boolean`	`addAll(Collection<? extends E> c)`
`void`	`addFirst(E e)`
`void`	`addLast(E e)`
`void`	`clear()`
`void`	`close()`
`void`	`computeProcedure(Consumer<SnapshotableDeque<E>> procedure)` Compute procedure undisturbed by concurrency updates.
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`DequeSnapshot<E>`	`createSnapshot()` create a snapshot
`DequeSnapshot<E>`	`createSnapshotPoll()` create a snapshot poll
`Iterator<E>`	`descendingIterator()`
`void`	`dispose()` Helps gc to clean memory.
`E`	`element()`
`boolean`	`equals(Object obj)`
`long`	`getCapacity()`
`E`	`getFirst()`
`E`	`getLast()`
`protected SnapshotableDeque.SnapshotVersion<E>`	`getModificationVersion()` Internal helper method returns current modification version.
`int`	`hashCode()`
`boolean`	`isEmpty()`
`Iterator<E>`	`iterator()`
`DequeNode<E>`	`link(SnapshotableDeque.LinkMode linkMode, E element)` link (append or prepend) new element to deque.
`boolean`	`offer(E e)`
`boolean`	`offerFirst(E e)`
`boolean`	`offerLast(E e)`
`E`	`peek()`
`E`	`peekFirst()`
`E`	`peekLast()`
`E`	`poll()`
`E`	`pollFirst()`
`E`	`pollLast()`
`E`	`pop()`
`void`	`push(E e)`
`void`	`registerEventHandler(INodeEventHandler<E> eventHandler)` register node event handler
`long`	`remainingCapacity()` returns the remaining capacity
`E`	`remove()`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> c)`
`E`	`removeFirst()`
`boolean`	`removeFirstOccurrence(Object o)`
`E`	`removeLast()`
`boolean`	`removeLastOccurrence(Object o)`
`protected void`	`removeSnapshotVersion(SnapshotableDeque.SnapshotVersion<E> snapshotVersion)` Internal method to remove snapshot and clean-ups
`boolean`	`retainAll(Collection<?> c)`
`void`	`setCapacity(long capacity)`
`protected void`	`setObsolete(DequeNode.Link<E> link)` Internal method to set link to obsolete
`int`	`size()`
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`
`void`	`unregisterEventHandler(INodeEventHandler<E> eventHandler)` unregister node event handler

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

Methods inherited from interface java.util.Collection
parallelStream, removeIf, spliterator, stream

Methods inherited from interface java.lang.Iterable
forEach

- Field Detail
  - rwLock
```
protected ReentrantReadWriteLock rwLock
```
  - readLock
```
protected ReentrantReadWriteLock.ReadLock readLock
```
  - writeLock
```
protected ReentrantReadWriteLock.WriteLock writeLock
```
  - begin
```
protected SnapshotableDeque.Bollard begin
```
  - end
```
protected SnapshotableDeque.Bollard end
```
  - obsoleteList
```
protected LinkedList<DequeNode.Link<E>> obsoleteList
```
  - modificationVersion
```
protected SnapshotableDeque.SnapshotVersion<E> modificationVersion
```
  - snapshotVersion
```
protected SnapshotableDeque.SnapshotVersion<E> snapshotVersion
```
  - openSnapshotVersionList
```
protected Set<SnapshotableDeque.SnapshotVersion<E>> openSnapshotVersionList
```
  - eventHandlerList
```
protected volatile LinkedList<INodeEventHandler<E>> eventHandlerList
```
  - nodeSize
```
protected volatile long nodeSize
```
  - capacity
```
protected volatile long capacity
```
  - uuid
```
protected UUID uuid
```
- Constructor Detail
  - SnapshotableDeque
```
public SnapshotableDeque()
```
    Constructor to create a SnapshotableDeque .
  - SnapshotableDeque
```
public SnapshotableDeque(long capacity)
```
    Constructor to create a SnapshotableDeque with specified capacity .
- Method Detail
  - getCapacity
```
public long getCapacity()
```
  - setCapacity
```
public void setCapacity(long capacity)
```
  - getModificationVersion
```
protected SnapshotableDeque.SnapshotVersion<E> getModificationVersion()
```
    Internal helper method returns current modification version. This method must invoke with SD.writeLock !
    Current modification version must be higher than current snapshot version.
    
    Returns:
  - remainingCapacity
```
public long remainingCapacity()
```
    returns the remaining capacity
    
    Returns:
    
    the remaining capacity
  - registerEventHandler
```
public void registerEventHandler(INodeEventHandler<E> eventHandler)
```
    register node event handler
    
    Parameters:
    
    eventHandler - event handler to register
  - unregisterEventHandler
```
public void unregisterEventHandler(INodeEventHandler<E> eventHandler)
```
    unregister node event handler
    
    Parameters:
    
    eventHandler - eventHandler event handler to unregister
  - removeSnapshotVersion
```
protected void removeSnapshotVersion(SnapshotableDeque.SnapshotVersion<E> snapshotVersion)
```
    Internal method to remove snapshot and clean-ups
    
    Parameters:
    
    snapshotVersion - version of deque
  - setObsolete
```
protected void setObsolete(DequeNode.Link<E> link)
```
    Internal method to set link to obsolete
    
    Parameters:
    
    link - link to set obsolete
  - computeProcedure
```
public void computeProcedure(Consumer<SnapshotableDeque<E>> procedure)
```
    Compute procedure undisturbed by concurrency updates.
    Don't create new Threads inside procedure. There is a risk of a deadlock
    
    Parameters:
    
    procedure -
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Collection<E>
    
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Specified by:
    
    equals in interface Collection<E>
    
    Overrides:
    
    equals in class Object
  - dispose
```
public void dispose()
```
    Helps gc to clean memory. After this the deque is not usable anymore.
  - link
```
public DequeNode<E> link(SnapshotableDeque.LinkMode linkMode,
                         E element)
```
    link (append or prepend) new element to deque. If capacity is reached a IllegalStateException is thrown.
    
    Parameters:
    
    linkMode - append or prepend
    
    element - item to link
    
    Returns:
    
    node
  - createSnapshot
```
public DequeSnapshot<E> createSnapshot()
```
    create a snapshot
    
    Returns:
    
    snapshot for specified
  - createSnapshotPoll
```
public DequeSnapshot<E> createSnapshotPoll()
```
    create a snapshot poll
    
    Returns:
    
    snapshot for specified
  - addAll
```
public boolean addAll(Collection<? extends E> c)
```
    Specified by:
    
    addAll in interface Collection<E>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<E>
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface Collection<E>
    
    Specified by:
    
    remove in interface Deque<E>
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Specified by:
    
    containsAll in interface Collection<E>
  - contains
```
public boolean contains(Object o)
```
    Specified by:
    
    contains in interface Collection<E>
    
    Specified by:
    
    contains in interface Deque<E>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Collection<E>
    
    Specified by:
    
    size in interface Deque<E>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Collection<E>
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Specified by:
    
    removeAll in interface Collection<E>
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Specified by:
    
    retainAll in interface Collection<E>
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<E>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface Collection<E>
  - add
```
public boolean add(E e)
```
    Specified by:
    
    add in interface Collection<E>
    
    Specified by:
    
    add in interface Deque<E>
    
    Specified by:
    
    add in interface Queue<E>
  - element
```
public E element()
```
    Specified by:
    
    element in interface Deque<E>
    
    Specified by:
    
    element in interface Queue<E>
  - offer
```
public boolean offer(E e)
```
    Specified by:
    
    offer in interface Deque<E>
    
    Specified by:
    
    offer in interface Queue<E>
  - peek
```
public E peek()
```
    Specified by:
    
    peek in interface Deque<E>
    
    Specified by:
    
    peek in interface Queue<E>
  - poll
```
public E poll()
```
    Specified by:
    
    poll in interface Deque<E>
    
    Specified by:
    
    poll in interface Queue<E>
  - remove
```
public E remove()
```
    Specified by:
    
    remove in interface Deque<E>
    
    Specified by:
    
    remove in interface Queue<E>
  - pop
```
public E pop()
```
    Specified by:
    
    pop in interface Deque<E>
  - push
```
public void push(E e)
```
    Specified by:
    
    push in interface Deque<E>
  - addFirst
```
public void addFirst(E e)
```
    Specified by:
    
    addFirst in interface Deque<E>
  - addLast
```
public void addLast(E e)
```
    Specified by:
    
    addLast in interface Deque<E>
  - offerFirst
```
public boolean offerFirst(E e)
```
    Specified by:
    
    offerFirst in interface Deque<E>
  - offerLast
```
public boolean offerLast(E e)
```
    Specified by:
    
    offerLast in interface Deque<E>
  - getFirst
```
public E getFirst()
```
    Specified by:
    
    getFirst in interface Deque<E>
  - getLast
```
public E getLast()
```
    Specified by:
    
    getLast in interface Deque<E>
  - peekFirst
```
public E peekFirst()
```
    Specified by:
    
    peekFirst in interface Deque<E>
  - peekLast
```
public E peekLast()
```
    Specified by:
    
    peekLast in interface Deque<E>
  - iterator
```
public Iterator<E> iterator()
```
    Specified by:
    
    iterator in interface Iterable<E>
    
    Specified by:
    
    iterator in interface Collection<E>
    
    Specified by:
    
    iterator in interface Deque<E>
  - descendingIterator
```
public Iterator<E> descendingIterator()
```
    Specified by:
    
    descendingIterator in interface Deque<E>
  - pollFirst
```
public E pollFirst()
```
    Specified by:
    
    pollFirst in interface Deque<E>
  - pollLast
```
public E pollLast()
```
    Specified by:
    
    pollLast in interface Deque<E>
  - removeFirst
```
public E removeFirst()
```
    Specified by:
    
    removeFirst in interface Deque<E>
  - removeLast
```
public E removeLast()
```
    Specified by:
    
    removeLast in interface Deque<E>
  - removeFirstOccurrence
```
public boolean removeFirstOccurrence(Object o)
```
    Specified by:
    
    removeFirstOccurrence in interface Deque<E>
  - removeLastOccurrence
```
public boolean removeLastOccurrence(Object o)
```
    Specified by:
    
    removeLastOccurrence in interface Deque<E>
  - close
```
public void close()
```
    Specified by:
    
    close in interface AutoCloseable

Class SnapshotableDeque<E>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Field Detail

rwLock

readLock

writeLock

begin

end

obsoleteList

modificationVersion

snapshotVersion

openSnapshotVersionList

eventHandlerList

nodeSize

capacity

uuid

Constructor Detail

SnapshotableDeque

SnapshotableDeque

Method Detail

getCapacity

setCapacity

getModificationVersion

remainingCapacity

registerEventHandler

unregisterEventHandler

removeSnapshotVersion

setObsolete

computeProcedure

hashCode

equals

dispose

link

createSnapshot

createSnapshotPoll

addAll

clear

remove

containsAll

contains

size

isEmpty

removeAll

retainAll

toArray

toArray

add

element

offer

peek

poll

remove

pop

push

addFirst

addLast

offerFirst

offerLast

getFirst

getLast

peekFirst

peekLast

iterator

descendingIterator

pollFirst

pollLast

removeFirst

removeLast

removeFirstOccurrence

removeLastOccurrence

close