java.lang.Object
- org.infinispan.multimap.impl.EmbeddedMultimapCache<K,V>

All Implemented Interfaces:

BasicMultimapCache<K,V>, MultimapCache<K,V>
```
public class EmbeddedMultimapCache<K,V>
extends Object
implements MultimapCache<K,V>
```
Embedded implementation of MultimapCache
Transactions
EmbeddedMultimapCache supports implicit transactions without blocking. The following methods block when they are called in a explicit transaction context. This limitation could be improved in the following versions if technically possible :
- BasicMultimapCache.size()
- BasicMultimapCache.containsEntry(Object, Object)
More about transactions in : the Infinispan Documentation.
Duplicates
The current implementation does not support duplicate values on keys. Object.equals(Object) method is used to check if a value is already present in the key. This means that the following code.
```
    multimapCache.put("k", "v1").join();
    multimapCache.put("k", "v2").join();
    multimapCache.put("k", "v2").join();
    multimapCache.put("k", "v2").join();

    multimapCache.get("k").thenAccept(values -> System.out.println(values.size()));
    // prints the value 2. "k" -> ["v1", "v2"]
 
```
Since:

9.2

Author:

Katia Aresti, karesti@redhat.com

Constructor Summary

Constructors
Constructor Description

EmbeddedMultimapCache(Cache<K,Collection<V>> cache)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`CompletableFuture<Boolean>`	`containsEntry(K key, V value)`	Returns `Boolean.TRUE` if this multimap cache contains the key-value pair.
`CompletableFuture<Boolean>`	`containsKey(K key)`	Returns `Boolean.TRUE` if this multimap cache contains the key.
`CompletableFuture<Boolean>`	`containsValue(V value)`	Asynchronous method that returns `Boolean.TRUE` if this multimap cache contains the value at any key.
`CompletableFuture<Collection<V>>`	`get(K key)`	Returns a view collection of the values associated with key in this multimap cache, if any.
`Cache<K,Collection<V>>`	`getCache()`
`CompletableFuture<Optional<CacheEntry<K,Collection<V>>>>`	`getEntry(K key)`	Retrieves a CacheEntry corresponding to a specific key in this multimap cache.
`CompletableFuture<Void>`	`put(K key, V value)`	Puts a key-value pair in this multimap cache.
`CompletableFuture<Void>`	`remove(Predicate<? super V> p)`	Asynchronous method.
`CompletableFuture<Boolean>`	`remove(K key)`	Removes all the key-value pairs associated with the key from this multimap cache, if such exists.
`CompletableFuture<Boolean>`	`remove(K key, V value)`	Removes a key-value pair from this multimap cache, if such exists.
`CompletableFuture<Long>`	`size()`	Returns the number of key-value pairs in this multimap cache.
`boolean`	`supportsDuplicates()`	Multimap can support duplicates on the same key k → ['a', 'a', 'b'] or not k → ['a', 'b'] depending on configuration.

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

Methods inherited from interface org.infinispan.multimap.api.embedded.MultimapCache
remove

- Constructor Detail
  - EmbeddedMultimapCache
```
public EmbeddedMultimapCache(Cache<K,Collection<V>> cache)
```
- Method Detail
  - put
```
public CompletableFuture<Void> put(K key,
                                   V value)
```
    Description copied from interface: BasicMultimapCache
    Puts a key-value pair in this multimap cache.
    
    If this multimap cache supports duplicates, the value will be always added.
    
    If this multimap cache does not support duplicates and the value exists on the key, nothing will be done.
    Specified by:
    
    put in interface BasicMultimapCache<K,V>
    
    Parameters:
    
    key - the key to be put
    
    value - the value to added
    
    Returns:
    
    CompletableFuture containing a Void
  - get
```
public CompletableFuture<Collection<V>> get(K key)
```
    Description copied from interface: BasicMultimapCache
    
    Returns a view collection of the values associated with key in this multimap cache, if any. Any changes to the retrieved collection won't change the values in this multimap cache. When this method returns an empty collection, it means the key was not found.
    
    Specified by:
    
    get in interface BasicMultimapCache<K,V>
    
    Parameters:
    
    key - to be retrieved
    
    Returns:
    
    a CompletableFuture containing which is a view of the underlying values.
  - getEntry
```
public CompletableFuture<Optional<CacheEntry<K,Collection<V>>>> getEntry(K key)
```
    Description copied from interface: MultimapCache
    
    Retrieves a CacheEntry corresponding to a specific key in this multimap cache.
    
    Specified by:
    
    getEntry in interface MultimapCache<K,V>
    
    Parameters:
    
    key - the key whose associated cache entry is to be returned
    
    Returns:
    
    the cache entry to which the specified key is mapped, or Optional.empty() if this multimap contains no mapping for the key
  - remove
```
public CompletableFuture<Boolean> remove(K key)
```
    Description copied from interface: BasicMultimapCache
    
    Removes all the key-value pairs associated with the key from this multimap cache, if such exists.
    
    Specified by:
    
    remove in interface BasicMultimapCache<K,V>
    
    Parameters:
    
    key - to be removed
    
    Returns:
    
    a CompletableFuture containing Boolean.TRUE if the entry was removed, and Boolean.FALSE when the entry was not removed
  - remove
```
public CompletableFuture<Boolean> remove(K key,
                                         V value)
```
    Description copied from interface: BasicMultimapCache
    Removes a key-value pair from this multimap cache, if such exists. Returns true when the key-value pair has been removed from the key.
    
    In the case where duplicates are not supported, only one the key-value pair will be removed, if such exists.
    
    In the case where duplicates are supported, all the key-value pairs will be removed.
    
    If the values remaining after the remove call are empty, the whole entry will be removed.
    Specified by:
    
    remove in interface BasicMultimapCache<K,V>
    
    Parameters:
    
    key - key to be removed
    
    value - value to be removed
    
    Returns:
    
    CompletableFuture containing Boolean.TRUE if the key-value pair was removed, and Boolean.FALSE when the key-value pair was not removed
  - remove
```
public CompletableFuture<Void> remove(Predicate<? super V> p)
```
    Description copied from interface: MultimapCache
    
    Asynchronous method. Removes every value that match the Predicate.
    This method is blocking used in a explicit transaction context.
    
    Specified by:
    
    remove in interface MultimapCache<K,V>
    
    Parameters:
    
    p - the predicate to be tested on every value in this multimap cache
    
    Returns:
    
    CompletableFuture containing a Void
  - containsKey
```
public CompletableFuture<Boolean> containsKey(K key)
```
    Description copied from interface: BasicMultimapCache
    
    Returns Boolean.TRUE if this multimap cache contains the key.
    
    Specified by:
    
    containsKey in interface BasicMultimapCache<K,V>
    
    Parameters:
    
    key - the key that might exists in this multimap cache
    
    Returns:
    
    CompletableFuture containing a Boolean
  - containsValue
```
public CompletableFuture<Boolean> containsValue(V value)
```
    Description copied from interface: BasicMultimapCache
    
    Asynchronous method that returns Boolean.TRUE if this multimap cache contains the value at any key.
    
    Specified by:
    
    containsValue in interface BasicMultimapCache<K,V>
    
    Parameters:
    
    value - the value that might exists in any entry
    
    Returns:
    
    CompletableFuture containing a Boolean
  - containsEntry
```
public CompletableFuture<Boolean> containsEntry(K key,
                                                V value)
```
    Description copied from interface: BasicMultimapCache
    
    Returns Boolean.TRUE if this multimap cache contains the key-value pair.
    
    Specified by:
    
    containsEntry in interface BasicMultimapCache<K,V>
    
    Parameters:
    
    key - the key of the key-value pair
    
    value - the value of the key-value pair
    
    Returns:
    
    CompletableFuture containing a Boolean
  - size
```
public CompletableFuture<Long> size()
```
    Description copied from interface: BasicMultimapCache
    
    Returns the number of key-value pairs in this multimap cache. It doesn't return the distinct number of keys.
    This method is blocking in a explicit transaction context.
    The CompletableFuture is a
    
    Specified by:
    
    size in interface BasicMultimapCache<K,V>
    
    Returns:
    
    CompletableFuture containing the size as Long
  - supportsDuplicates
```
public boolean supportsDuplicates()
```
    Description copied from interface: BasicMultimapCache
    
    Multimap can support duplicates on the same key k → ['a', 'a', 'b'] or not k → ['a', 'b'] depending on configuration.
    Returns duplicates are supported or not in this multimap cache.
    
    Specified by:
    
    supportsDuplicates in interface BasicMultimapCache<K,V>
    
    Returns:
    
    true if this multimap supports duplicate values for a given key.
  - getCache
```
public Cache<K,Collection<V>> getCache()
```

Class EmbeddedMultimapCache<K,​V>

Transactions

Duplicates

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.infinispan.multimap.api.embedded.MultimapCache

Constructor Detail

EmbeddedMultimapCache

Method Detail

put

get

getEntry

remove

remove

remove

containsKey

containsValue

containsEntry

size

supportsDuplicates

getCache

Class EmbeddedMultimapCache<K,V>