EventuallyConsistentMapBuilderImpl (onos-apps-fwd)

java.lang.Object
- org.onosproject.store.primitives.impl.EventuallyConsistentMapBuilderImpl<K,V>

All Implemented Interfaces:: EventuallyConsistentMapBuilder<K,V>

public class EventuallyConsistentMapBuilderImpl<K,V>
extends Object
implements EventuallyConsistentMapBuilder<K,V>

Eventually consistent map builder.

Constructor Summary

Constructors
Constructor and Description
`EventuallyConsistentMapBuilderImpl(ClusterService clusterService, ClusterCommunicationService clusterCommunicator, PersistenceService persistenceService)` Creates a new eventually consistent map builder.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`EventuallyConsistentMap<K,V>`	`build()` Builds an eventually consistent map based on the configuration options supplied to this builder.
`EventuallyConsistentMapBuilder<K,V>`	`withAntiEntropyPeriod(long period, TimeUnit unit)` Configures how often to run the anti-entropy background task.
`EventuallyConsistentMapBuilder<K,V>`	`withBackgroundExecutor(ScheduledExecutorService executor)` Sets the executor to use for background anti-entropy tasks.
`EventuallyConsistentMapBuilder<K,V>`	`withCommunicationExecutor(ExecutorService executor)` Sets the executor to use for sending events to peers.
`EventuallyConsistentMapBuilder<K,V>`	`withEventExecutor(ExecutorService executor)` Sets the executor to use for processing events coming in from peers.
`EventuallyConsistentMapBuilder<K,V>`	`withFasterConvergence()` Configure anti-entropy to converge faster at the cost of doing more work for each anti-entropy cycle.
`EventuallyConsistentMapBuilder<K,V>`	`withName(String name)` Sets the name of the map.
`EventuallyConsistentMapBuilder<K,V>`	`withPeerUpdateFunction(BiFunction<K,V,Collection<NodeId>> peerUpdateFunction)` Sets a function that can determine which peers to replicate updates to.
`EventuallyConsistentMapBuilder<K,V>`	`withPersistence()` Configure the map to persist data to disk.
`EventuallyConsistentMapBuilder<K,V>`	`withSerializer(org.onlab.util.KryoNamespace.Builder serializerBuilder)` Sets a serializer builder that can be used to create a serializer that can serialize both the keys and values put into the map.
`EventuallyConsistentMapBuilder<K,V>`	`withSerializer(org.onlab.util.KryoNamespace serializer)` Sets a serializer that can be used to create a serializer that can serialize both the keys and values put into the map.
`EventuallyConsistentMapBuilder<K,V>`	`withTimestampProvider(BiFunction<K,V,Timestamp> timestampProvider)` Sets the function to use for generating timestamps for map updates.
`EventuallyConsistentMapBuilder<K,V>`	`withTombstonesDisabled()` Prevents this map from writing tombstones of items that have been removed.

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

- Constructor Detail
  - EventuallyConsistentMapBuilderImpl
```
public EventuallyConsistentMapBuilderImpl(ClusterService clusterService,
                                          ClusterCommunicationService clusterCommunicator,
                                          PersistenceService persistenceService)
```
    Creates a new eventually consistent map builder.
    
    Parameters:
    
    clusterService - cluster service
    
    clusterCommunicator - cluster communication service
    
    persistenceService - persistence service
- Method Detail
  - withName
```
public EventuallyConsistentMapBuilder<K,V> withName(String name)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Sets the name of the map.
    Each map is identified by a string map name. EventuallyConsistentMapImpl objects in different JVMs that use the same map name will form a distributed map across JVMs (provided the cluster service is aware of both nodes).
    
    Note: This is a mandatory parameter.
    
    Specified by:
    
    withName in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    name - name of the map
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withSerializer
```
public EventuallyConsistentMapBuilder<K,V> withSerializer(org.onlab.util.KryoNamespace.Builder serializerBuilder)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Sets a serializer builder that can be used to create a serializer that can serialize both the keys and values put into the map. The serializer builder should be pre-populated with any classes that will be put into the map.
    Note: This is a mandatory parameter.
    
    Specified by:
    
    withSerializer in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    serializerBuilder - serializer builder
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withSerializer
```
public EventuallyConsistentMapBuilder<K,V> withSerializer(org.onlab.util.KryoNamespace serializer)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Sets a serializer that can be used to create a serializer that can serialize both the keys and values put into the map. The serializer builder should be pre-populated with any classes that will be put into the map.
    Note: This is a mandatory parameter.
    
    Specified by:
    
    withSerializer in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    serializer - serializer
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withTimestampProvider
```
public EventuallyConsistentMapBuilder<K,V> withTimestampProvider(BiFunction<K,V,Timestamp> timestampProvider)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Sets the function to use for generating timestamps for map updates.
    The client must provide an BiFunction<K, V, Timestamp> which can generate timestamps for a given key. The function is free to generate timestamps however it wishes, however these timestamps will be used to serialize updates to the map so they must be strict enough to ensure updates are properly ordered for the use case (i.e. in some cases wallclock time will suffice, whereas in other cases logical time will be necessary).
    
    Note: This is a mandatory parameter.
    
    Specified by:
    
    withTimestampProvider in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    timestampProvider - provides a new timestamp
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withEventExecutor
```
public EventuallyConsistentMapBuilder<K,V> withEventExecutor(ExecutorService executor)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Sets the executor to use for processing events coming in from peers.
    
    Specified by:
    
    withEventExecutor in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    executor - event executor
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withCommunicationExecutor
```
public EventuallyConsistentMapBuilder<K,V> withCommunicationExecutor(ExecutorService executor)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Sets the executor to use for sending events to peers.
    
    Specified by:
    
    withCommunicationExecutor in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    executor - event executor
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withBackgroundExecutor
```
public EventuallyConsistentMapBuilder<K,V> withBackgroundExecutor(ScheduledExecutorService executor)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Sets the executor to use for background anti-entropy tasks.
    
    Specified by:
    
    withBackgroundExecutor in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    executor - event executor
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withPeerUpdateFunction
```
public EventuallyConsistentMapBuilder<K,V> withPeerUpdateFunction(BiFunction<K,V,Collection<NodeId>> peerUpdateFunction)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Sets a function that can determine which peers to replicate updates to.
    The default function replicates to all nodes.
    
    Specified by:
    
    withPeerUpdateFunction in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    peerUpdateFunction - function that takes a K, V input and returns a collection of NodeIds to replicate the event to
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withTombstonesDisabled
```
public EventuallyConsistentMapBuilder<K,V> withTombstonesDisabled()
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Prevents this map from writing tombstones of items that have been removed. This may result in zombie items reappearing after they have been removed.
    The default behavior is tombstones are enabled.
    
    Specified by:
    
    withTombstonesDisabled in interface EventuallyConsistentMapBuilder<K,V>
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withAntiEntropyPeriod
```
public EventuallyConsistentMapBuilder<K,V> withAntiEntropyPeriod(long period,
                                                                 TimeUnit unit)
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Configures how often to run the anti-entropy background task.
    The default anti-entropy period is 5 seconds.
    
    Specified by:
    
    withAntiEntropyPeriod in interface EventuallyConsistentMapBuilder<K,V>
    
    Parameters:
    
    period - anti-entropy period
    
    unit - time unit for the period
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withFasterConvergence
```
public EventuallyConsistentMapBuilder<K,V> withFasterConvergence()
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Configure anti-entropy to converge faster at the cost of doing more work for each anti-entropy cycle. Suited to maps with low update rate where convergence time is more important than throughput.
    The default behavior is to do less anti-entropy work at the cost of slower convergence.
    
    Specified by:
    
    withFasterConvergence in interface EventuallyConsistentMapBuilder<K,V>
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - withPersistence
```
public EventuallyConsistentMapBuilder<K,V> withPersistence()
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Configure the map to persist data to disk.
    The default behavior is no persistence
    
    Specified by:
    
    withPersistence in interface EventuallyConsistentMapBuilder<K,V>
    
    Returns:
    
    this EventuallyConsistentMapBuilder
  - build
```
public EventuallyConsistentMap<K,V> build()
```
    Description copied from interface: EventuallyConsistentMapBuilder
    
    Builds an eventually consistent map based on the configuration options supplied to this builder.
    
    Specified by:
    
    build in interface EventuallyConsistentMapBuilder<K,V>
    
    Returns:
    
    new eventually consistent map

Class EventuallyConsistentMapBuilderImpl<K,V>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

EventuallyConsistentMapBuilderImpl

Method Detail

withName

withSerializer

withSerializer

withTimestampProvider

withEventExecutor

withCommunicationExecutor

withBackgroundExecutor

withPeerUpdateFunction

withTombstonesDisabled

withAntiEntropyPeriod

withFasterConvergence

withPersistence

build