DefaultConsistentMultimap (ONOS Java API (2.1.0))

java.lang.Object
- org.onosproject.store.service.Synchronous<AsyncConsistentMultimap<K,V>>
- - org.onosproject.store.primitives.DefaultConsistentMultimap<K,V>

All Implemented Interfaces:

Iterable<Map.Entry<K,V>>, ConsistentMultimap<K,V>, DistributedPrimitive
```
public class DefaultConsistentMultimap<K,V>
extends Synchronous<AsyncConsistentMultimap<K,V>>
implements ConsistentMultimap<K,V>
```
Implementation of ConsistentMultimap providing synchronous access to AsyncConsistentMultimap.

Nested Class Summary
- Nested classes/interfaces inherited from interface org.onosproject.store.service.DistributedPrimitive
  DistributedPrimitive.Status, DistributedPrimitive.Type

Field Summary
- Fields inherited from interface org.onosproject.store.service.DistributedPrimitive
  DEFAULT_OPERATION_TIMEOUT_MILLIS

Constructor Summary

Constructors
Constructor and Description

DefaultConsistentMultimap(AsyncConsistentMultimap<K,V> asyncMultimap, long operationTimeoutMillis)

Constructors
Constructor and Description
`DefaultConsistentMultimap(AsyncConsistentMultimap<K,V> asyncMultimap, long operationTimeoutMillis)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addListener(MultimapEventListener<K,V> listener, Executor executor)` Registers the specified listener to be notified whenever the map is updated.
`Map<K,Collection<V>>`	`asMap()` Returns a map of keys to collections of values that reflect the set of key-value pairs contained in the multimap, where the key value pairs would be the key paired with each of the values in the collection.
`void`	`clear()` Removes all key-value pairs, after which it will be empty.
`boolean`	`containsEntry(K key, V value)` Returns true if this map contains at least one key-value pair with key and value specified.
`boolean`	`containsKey(K key)` Returns true if there is at lease one key-value pair with a key equal to key.
`boolean`	`containsValue(V value)` Returns true if this map contains at lease one key-value pair with a value equal to value.
`Collection<Map.Entry<K,V>>`	`entries()` Returns a collection of each key-value pair in this map.
`Versioned<Collection<? extends V>>`	`get(K key)` Returns a collection of values associated with the specified key, if the key is not in the map it will return an empty collection.
`boolean`	`isEmpty()` Returns if this multimap contains no key-value pairs.
`Iterator<Map.Entry<K,V>>`	`iterator()`
`com.google.common.collect.Multiset<K>`	`keys()` Returns a multiset of the keys present in this multimap with one or more associated values each.
`Set<K>`	`keySet()` Returns a set of the keys contained in this multimap with one or more associated values.
`boolean`	`put(K key, V value)` If the key-value pair does not already exist adds either the key value pair or the value to the set of values associated with the key and returns true, if the key-value pair already exists then behavior is implementation specific with some implementations allowing duplicates and others ignoring put requests for existing entries.
`boolean`	`putAll(K key, Collection<? extends V> values)` Adds the set of key-value pairs of the specified key with each of the values in the iterable if each key-value pair does not already exist, if the pair does exist the behavior is implementation specific.
`Versioned<Collection<? extends V>>`	`putAndGet(K key, V value)` If the key-value pair does not already exist adds either the key value pair or the value to the set of values associated with the key and returns the updated value, if the key-value pair already exists then behavior is implementation specific with some implementations allowing duplicates and others ignoring put requests for existing entries.
`boolean`	`remove(K key, V value)` Removes the key-value pair with the specified values if it exists.
`Versioned<Collection<? extends V>>`	`removeAll(K key)` Removes all values associated with the specified key as well as the key itself.
`boolean`	`removeAll(K key, Collection<? extends V> values)` Removes the key-value pairs with the specified key and values if they exist.
`Versioned<Collection<? extends V>>`	`removeAndGet(K key, V value)` Removes the key-value pair with the specified values if it exists.
`void`	`removeListener(MultimapEventListener<K,V> listener)` Unregisters the specified listener such that it will no longer receive map change notifications.
`Versioned<Collection<? extends V>>`	`replaceValues(K key, Collection<V> values)` Stores all the values in values associated with the key specified, removes all preexisting values and returns a collection of the removed values which may be empty if the entry did not exist.
`int`	`size()` Returns the number of key-value pairs in this multimap.
`com.google.common.collect.Multiset<V>`	`values()` Returns a collection of values in the set with duplicates permitted, the size of this collection will equal the size of the map at the time of creation.

Methods inherited from class org.onosproject.store.service.Synchronous
destroy, name, primitiveType

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

Methods inherited from interface org.onosproject.store.service.ConsistentMultimap
addListener, stream

Methods inherited from interface org.onosproject.store.service.DistributedPrimitive
addStatusChangeListener, applicationId, destroy, name, primitiveType, removeStatusChangeListener, statusChangeListeners

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - DefaultConsistentMultimap
```
public DefaultConsistentMultimap(AsyncConsistentMultimap<K,V> asyncMultimap,
                                 long operationTimeoutMillis)
```
- Method Detail
  - size
```
public int size()
```
    Description copied from interface: ConsistentMultimap
    
    Returns the number of key-value pairs in this multimap.
    
    Specified by:
    
    size in interface ConsistentMultimap<K,V>
    
    Returns:
    
    the number of key-value pairs
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: ConsistentMultimap
    
    Returns if this multimap contains no key-value pairs.
    
    Specified by:
    
    isEmpty in interface ConsistentMultimap<K,V>
    
    Returns:
    
    true if no key-value pairs exist, false otherwise
  - containsKey
```
public boolean containsKey(K key)
```
    Description copied from interface: ConsistentMultimap
    
    Returns true if there is at lease one key-value pair with a key equal to key.
    
    Specified by:
    
    containsKey in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key to query
    
    Returns:
    
    true if the map contains a key-value pair with key false otherwise
  - containsValue
```
public boolean containsValue(V value)
```
    Description copied from interface: ConsistentMultimap
    
    Returns true if this map contains at lease one key-value pair with a value equal to value.
    
    Specified by:
    
    containsValue in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    value - the value to query
    
    Returns:
    
    true if there is a key-value pair with the specified value, false otherwise.
  - containsEntry
```
public boolean containsEntry(K key,
                             V value)
```
    Description copied from interface: ConsistentMultimap
    
    Returns true if this map contains at least one key-value pair with key and value specified.
    
    Specified by:
    
    containsEntry in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key to query
    
    value - the value to query
    
    Returns:
    
    true if there is a key-value pair with the specified key and value, false otherwise.
  - put
```
public boolean put(K key,
                   V value)
```
    Description copied from interface: ConsistentMultimap
    
    If the key-value pair does not already exist adds either the key value pair or the value to the set of values associated with the key and returns true, if the key-value pair already exists then behavior is implementation specific with some implementations allowing duplicates and others ignoring put requests for existing entries.
    
    Specified by:
    
    put in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key to add
    
    value - the value to add
    
    Returns:
    
    true if the map has changed because of this call, false otherwise
  - putAndGet
```
public Versioned<Collection<? extends V>> putAndGet(K key,
                                                    V value)
```
    Description copied from interface: ConsistentMultimap
    
    If the key-value pair does not already exist adds either the key value pair or the value to the set of values associated with the key and returns the updated value, if the key-value pair already exists then behavior is implementation specific with some implementations allowing duplicates and others ignoring put requests for existing entries.
    
    Specified by:
    
    putAndGet in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key to add
    
    value - the value to add
    
    Returns:
    
    the updated values
  - remove
```
public boolean remove(K key,
                      V value)
```
    Description copied from interface: ConsistentMultimap
    
    Removes the key-value pair with the specified values if it exists. In implementations that allow duplicates which matching entry will be removed is undefined.
    
    Specified by:
    
    remove in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key of the pair to be removed
    
    value - the value of the pair to be removed
    
    Returns:
    
    true if the map changed because of this call, false otherwise.
  - removeAndGet
```
public Versioned<Collection<? extends V>> removeAndGet(K key,
                                                       V value)
```
    Description copied from interface: ConsistentMultimap
    
    Removes the key-value pair with the specified values if it exists. In implementations that allow duplicates which matching entry will be removed is undefined.
    
    Specified by:
    
    removeAndGet in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key of the pair to be removed
    
    value - the value of the pair to be removed
    
    Returns:
    
    the updated values
  - removeAll
```
public boolean removeAll(K key,
                         Collection<? extends V> values)
```
    Description copied from interface: ConsistentMultimap
    
    Removes the key-value pairs with the specified key and values if they exist. In implementations that allow duplicates each instance of a key will remove one matching entry, which one is not defined. Equivalent to repeated calls to remove() for each key value pair but more efficient.
    
    Specified by:
    
    removeAll in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key of the pair to be removed
    
    values - the set of values to be removed
    
    Returns:
    
    true if the map changes because of this call, false otherwise.
  - removeAll
```
public Versioned<Collection<? extends V>> removeAll(K key)
```
    Description copied from interface: ConsistentMultimap
    
    Removes all values associated with the specified key as well as the key itself.
    
    Specified by:
    
    removeAll in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key whose key-value pairs will be removed
    
    Returns:
    
    the set of values that were removed, which may be empty, if the values did not exist the version will be less than one.
  - putAll
```
public boolean putAll(K key,
                      Collection<? extends V> values)
```
    Description copied from interface: ConsistentMultimap
    
    Adds the set of key-value pairs of the specified key with each of the values in the iterable if each key-value pair does not already exist, if the pair does exist the behavior is implementation specific. (Same as repeated puts but with efficiency gains.)
    
    Specified by:
    
    putAll in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key to use for all pairs to be added
    
    values - the set of values to be added in pairs with the key
    
    Returns:
    
    true if any change in the map results from this call, false otherwise
  - replaceValues
```
public Versioned<Collection<? extends V>> replaceValues(K key,
                                                        Collection<V> values)
```
    Description copied from interface: ConsistentMultimap
    
    Stores all the values in values associated with the key specified, removes all preexisting values and returns a collection of the removed values which may be empty if the entry did not exist.
    
    Specified by:
    
    replaceValues in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key for all entries to be added
    
    values - the values to be associated with the key
    
    Returns:
    
    the collection of removed values, which may be empty
  - clear
```
public void clear()
```
    Description copied from interface: ConsistentMultimap
    
    Removes all key-value pairs, after which it will be empty.
    
    Specified by:
    
    clear in interface ConsistentMultimap<K,V>
  - get
```
public Versioned<Collection<? extends V>> get(K key)
```
    Description copied from interface: ConsistentMultimap
    
    Returns a collection of values associated with the specified key, if the key is not in the map it will return an empty collection.
    
    Specified by:
    
    get in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    key - the key whose associated values will be returned
    
    Returns:
    
    the collection of the values associated with the specified key, the collection may be empty
  - keySet
```
public Set<K> keySet()
```
    Description copied from interface: ConsistentMultimap
    
    Returns a set of the keys contained in this multimap with one or more associated values.
    
    Specified by:
    
    keySet in interface ConsistentMultimap<K,V>
    
    Returns:
    
    the collection of all keys with one or more associated values, this may be empty
  - keys
```
public com.google.common.collect.Multiset<K> keys()
```
    Description copied from interface: ConsistentMultimap
    
    Returns a multiset of the keys present in this multimap with one or more associated values each. Keys will appear once for each key-value pair in which they participate.
    
    Specified by:
    
    keys in interface ConsistentMultimap<K,V>
    
    Returns:
    
    a multiset of the keys, this may be empty
  - values
```
public com.google.common.collect.Multiset<V> values()
```
    Description copied from interface: ConsistentMultimap
    
    Returns a collection of values in the set with duplicates permitted, the size of this collection will equal the size of the map at the time of creation.
    
    Specified by:
    
    values in interface ConsistentMultimap<K,V>
    
    Returns:
    
    a collection of values, this may be empty
  - entries
```
public Collection<Map.Entry<K,V>> entries()
```
    Description copied from interface: ConsistentMultimap
    
    Returns a collection of each key-value pair in this map.
    Do not use this method to read large maps. Use an Iterable.iterator() or ConsistentMultimap.stream() instead.
    
    Specified by:
    
    entries in interface ConsistentMultimap<K,V>
    
    Returns:
    
    a collection of all entries in the map, this may be empty
  - iterator
```
public Iterator<Map.Entry<K,V>> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Map.Entry<K,V>>
  - asMap
```
public Map<K,Collection<V>> asMap()
```
    Description copied from interface: ConsistentMultimap
    
    Returns a map of keys to collections of values that reflect the set of key-value pairs contained in the multimap, where the key value pairs would be the key paired with each of the values in the collection.
    
    Specified by:
    
    asMap in interface ConsistentMultimap<K,V>
    
    Returns:
    
    a map of keys to collections of values, the returned map may be empty.
  - addListener
```
public void addListener(MultimapEventListener<K,V> listener,
                        Executor executor)
```
    Description copied from interface: ConsistentMultimap
    
    Registers the specified listener to be notified whenever the map is updated.
    
    Specified by:
    
    addListener in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    listener - listener to notify about map events
    
    executor - executor to use for handling incoming map events
  - removeListener
```
public void removeListener(MultimapEventListener<K,V> listener)
```
    Description copied from interface: ConsistentMultimap
    
    Unregisters the specified listener such that it will no longer receive map change notifications.
    
    Specified by:
    
    removeListener in interface ConsistentMultimap<K,V>
    
    Parameters:
    
    listener - listener to unregister

Class DefaultConsistentMultimap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface org.onosproject.store.service.DistributedPrimitive

Field Summary

Fields inherited from interface org.onosproject.store.service.DistributedPrimitive

Constructor Summary

Method Summary

Methods inherited from class org.onosproject.store.service.Synchronous

Methods inherited from class java.lang.Object

Methods inherited from interface org.onosproject.store.service.ConsistentMultimap

Methods inherited from interface org.onosproject.store.service.DistributedPrimitive

Methods inherited from interface java.lang.Iterable

Constructor Detail

DefaultConsistentMultimap

Method Detail

size

isEmpty

containsKey

containsValue

containsEntry

put

putAndGet

remove

removeAndGet

removeAll

removeAll

putAll

replaceValues

clear

get

keySet

keys

values

entries

iterator

asMap

addListener

removeListener