Package org.onosproject.store.service

Interface ConsistentMultimap<K,​V>

  • All Superinterfaces:
    DistributedPrimitive, java.lang.Iterable<java.util.Map.Entry<K,​V>>
    All Known Implementing Classes:
    DefaultConsistentMultimap
    public interface ConsistentMultimap<K,​V>
extends DistributedPrimitive, java.lang.Iterable<java.util.Map.Entry<K,​V>>
    This provides a synchronous version of the functionality provided by AsyncConsistentMultimap. Instead of returning futures this map blocks until the future completes then returns the result.

    • Method Summary

      All Methods Instance Methods Abstract Methods Default Methods 
      Modifier and Type Method Description
      default void addListener​(MultimapEventListener<K,​V> listener)
      Registers the specified listener to be notified whenever the map is updated.
      void addListener​(MultimapEventListener<K,​V> listener, java.util.concurrent.Executor executor)
      Registers the specified listener to be notified whenever the map is updated.
      java.util.Map<K,​java.util.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.
      java.util.Collection<java.util.Map.Entry<K,​V>> entries()
      Returns a collection of each key-value pair in this map.
      Versioned<java.util.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.
      com.google.common.collect.Multiset<K> keys()
      Returns a multiset of the keys present in this multimap with one or more associated values each.
      java.util.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, java.util.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<java.util.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<java.util.Collection<? extends V>> removeAll​(K key)
      Removes all values associated with the specified key as well as the key itself.
      boolean removeAll​(K key, java.util.Collection<? extends V> values)
      Removes the key-value pairs with the specified key and values if they exist.
      Versioned<java.util.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<java.util.Collection<? extends V>> replaceValues​(K key, java.util.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.
      default java.util.stream.Stream<java.util.Map.Entry<K,​V>> stream()
      Streams entries from the map.
      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 interface java.lang.Iterable

        forEach, iterator, spliterator

    • Method Detail

      • size

        int size()
        Returns the number of key-value pairs in this multimap.
        Returns:
        the number of key-value pairs

      • isEmpty

        boolean isEmpty()
        Returns if this multimap contains no key-value pairs.
        Returns:
        true if no key-value pairs exist, false otherwise

      • containsKey

        boolean containsKey​(K key)
        Returns true if there is at lease one key-value pair with a key equal to key.
        Parameters:
        key - the key to query
        Returns:
        true if the map contains a key-value pair with key false otherwise

      • containsValue

        boolean containsValue​(V value)
        Returns true if this map contains at lease one key-value pair with a value equal to value.
        Parameters:
        value - the value to query
        Returns:
        true if there is a key-value pair with the specified value, false otherwise.

      • containsEntry

        boolean containsEntry​(K key,
                      V value)
        Returns true if this map contains at least one key-value pair with key and value specified.
        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

        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.
        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

        Versioned<java.util.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.
        Parameters:
        key - the key to add
        value - the value to add
        Returns:
        the updated values

      • remove

        boolean remove​(K key,
               V value)
        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.
        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

        Versioned<java.util.Collection<? extends V>> removeAndGet​(K key,
                                                          V value)
        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.
        Parameters:
        key - the key of the pair to be removed
        value - the value of the pair to be removed
        Returns:
        the updated values

      • removeAll

        boolean removeAll​(K key,
                  java.util.Collection<? extends V> values)
        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.
        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

        Versioned<java.util.Collection<? extends V>> removeAll​(K key)
        Removes all values associated with the specified key as well as the key itself.
        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

        boolean putAll​(K key,
               java.util.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. (Same as repeated puts but with efficiency gains.)
        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

        Versioned<java.util.Collection<? extends V>> replaceValues​(K key,
                                                           java.util.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.
        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

        void clear()
        Removes all key-value pairs, after which it will be empty.

      • get

        Versioned<java.util.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.
        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

        java.util.Set<K> keySet()
        Returns a set of the keys contained in this multimap with one or more associated values.
        Returns:
        the collection of all keys with one or more associated values, this may be empty

      • keys

        com.google.common.collect.Multiset<K> keys()
        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.
        Returns:
        a multiset of the keys, this may be empty

      • values

        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.
        Returns:
        a collection of values, this may be empty

      • entries

        java.util.Collection<java.util.Map.Entry<K,​V>> entries()
        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 stream() instead.

        Returns:
        a collection of all entries in the map, this may be empty

      • stream

        default java.util.stream.Stream<java.util.Map.Entry<K,​V>> stream()
        Streams entries from the map.

        This method is optimized for large maps.

        Returns:
        the map entry stream

      • asMap

        java.util.Map<K,​java.util.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.
        Returns:
        a map of keys to collections of values, the returned map may be empty.

      • addListener

        default void addListener​(MultimapEventListener<K,​V> listener)
        Registers the specified listener to be notified whenever the map is updated.
        Parameters:
        listener - listener to notify about map events

      • addListener

        void addListener​(MultimapEventListener<K,​V> listener,
                 java.util.concurrent.Executor executor)
        Registers the specified listener to be notified whenever the map is updated.
        Parameters:
        listener - listener to notify about map events
        executor - executor to use for handling incoming map events

      • removeListener

        void removeListener​(MultimapEventListener<K,​V> listener)
        Unregisters the specified listener such that it will no longer receive map change notifications.
        Parameters:
        listener - listener to unregister