Package org.redisson.api

Interface CacheRx<K,​V>

  • Type Parameters:
    K - key type
    V - value type
    public interface CacheRx<K,​V>
    RxJava2 interface for JCache
    Author:
    Nikita Koksharov

    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      io.reactivex.rxjava3.core.Completable clear()
      This method empties the cache's contents, without notifying listeners or CacheWriters.
      io.reactivex.rxjava3.core.Single<Boolean> containsKey​(K key)
      This method returns a Boolean true/false value, depending on whether the CacheRx has a mapping for a key k such that key.equals(k).
      io.reactivex.rxjava3.core.Maybe<V> get​(K key)
      This method retrieves an entry from the cache.
      io.reactivex.rxjava3.core.Single<Map<K,​V>> getAll​(Set<? extends K> keys)
      This method accepts a set of requested keys and retrieves a collection of entries from the CacheRx, returning them as a Map of the associated values.
      io.reactivex.rxjava3.core.Maybe<V> getAndPut​(K key, V value)
      This method places the given key and value in the cache.
      io.reactivex.rxjava3.core.Maybe<V> getAndRemove​(K key)
      This method atomically removes the entry for a key only if it is currently mapped to some value.
      io.reactivex.rxjava3.core.Maybe<V> getAndReplace​(K key, V value)
      This method atomically replaces a given key's value if and only if the key is currently mapped to a value.
      io.reactivex.rxjava3.core.Completable put​(K key, V value)
      This method places the given value V in the cache and associates it with the given key K.
      io.reactivex.rxjava3.core.Completable putAll​(Map<? extends K,​? extends V> map)
      This method copies all of the entries from the given Map to the CacheRx.
      io.reactivex.rxjava3.core.Single<Boolean> putIfAbsent​(K key, V value)
      This method places the given key and value in the cache atomically, if the key is not already associated with a value in the cache.
      io.reactivex.rxjava3.core.Single<Boolean> remove​(K key)
      This method deletes the mapping for a given key from the cache, if it is present.
      io.reactivex.rxjava3.core.Single<Boolean> remove​(K key, V oldValue)
      This method atomically removes a key's mapping only if it is currently mapped to the provided value.
      io.reactivex.rxjava3.core.Completable removeAll​(Set<? extends K> keys)
      This method deletes the entries for the given keys.
      io.reactivex.rxjava3.core.Single<Boolean> replace​(K key, V value)
      This method atomically replaces an entry only if the key is currently mapped to some value.
      io.reactivex.rxjava3.core.Single<Boolean> replace​(K key, V oldValue, V newValue)
      This method atomically replaces an entry only if the key is currently mapped to a given value.

    • Method Detail

      • get

        io.reactivex.rxjava3.core.Maybe<V> get​(K key)
        This method retrieves an entry from the cache. If the cache uses the read-through pattern, and the method would return null because the entry is not present in the cache, then the cache's CacheLoader will try to load the entry.
        Parameters:
        key - the key whose value should be returned
        Returns:
        the element, or null if the entry does not exist.
        Throws:
        IllegalStateException - if the cache is in a closed state
        NullPointerException - if the key is null
        javax.cache.CacheException - if there is a problem retrieving the entry from the cache

      • getAll

        io.reactivex.rxjava3.core.Single<Map<K,​V>> getAll​(Set<? extends K> keys)
        This method accepts a set of requested keys and retrieves a collection of entries from the CacheRx, returning them as a Map of the associated values. If the cache uses the read-through pattern, and the method would return null for a key because an entry is not present in the cache, the Cache's CacheLoader will try to load the entry. If a key's entry cannot be loaded, the key will not appear in the Map.
        Parameters:
        keys - The keys whose values should be returned.
        Returns:
        A Map of entries associated with the given keys. If a key is not found in the cache, it will not be in the Map.
        Throws:
        NullPointerException - if keys is null or contains a null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem retrieving the entries from the cache

      • containsKey

        io.reactivex.rxjava3.core.Single<Boolean> containsKey​(K key)
        This method returns a Boolean true/false value, depending on whether the CacheRx has a mapping for a key k such that key.equals(k).
        Parameters:
        key - the key with a possible mapping in the cache.
        Returns:
        true if such a mapping exists
        Throws:
        NullPointerException - if key is null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • put

        io.reactivex.rxjava3.core.Completable put​(K key,
                                          V value)
        This method places the given value V in the cache and associates it with the given key K. If the CacheRx already has a mapping for the key, the previous value is replaced by the given value V. This occurs if and only if c.containsKey(k) would return true.)
        Parameters:
        key - the key to place in the cache
        value - the value to associate with the given key
        Returns:
        void
        Throws:
        NullPointerException - if the key or value is null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • getAndPut

        io.reactivex.rxjava3.core.Maybe<V> getAndPut​(K key,
                                             V value)
        This method places the given key and value in the cache. Any value already in the cache is returned and replaced by the new given value. This occurs if and only if c.containsKey(k) would return true.) If there was no value already in the cache, the method returns null.
        Parameters:
        key - the key to place in the cache
        value - the value to associate with the given key
        Returns:
        the previous value in the cache, or null if none already existed
        Throws:
        NullPointerException - if the key or value is null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • putAll

        io.reactivex.rxjava3.core.Completable putAll​(Map<? extends K,​? extends V> map)
        This method copies all of the entries from the given Map to the CacheRx. This method is equivalent to calling put(k, v) on this cache one time for each mapping from key k to value v in the given Map. Individual puts may occur in any order. If entries in the cache corresponding to entries in the Map, or the Map itself, is changed or removed during this operation, then the behavior of this method is not defined. If default consistency mode is enabled, then each put is atomic but not the entire putAll operation. Listeners can observe individual updates.
        Parameters:
        map - the Map that contains the entries to be copied to the cache
        Returns:
        void
        Throws:
        NullPointerException - if the map is null or contains null keys or values.
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache.

      • putIfAbsent

        io.reactivex.rxjava3.core.Single<Boolean> putIfAbsent​(K key,
                                                      V value)
        This method places the given key and value in the cache atomically, if the key is not already associated with a value in the cache.
        Parameters:
        key - the key to place in the cache
        value - the value to associate with the given key
        Returns:
        true if the value was successfully placed in the cache
        Throws:
        NullPointerException - if the key or value is null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • remove

        io.reactivex.rxjava3.core.Single<Boolean> remove​(K key)
        This method deletes the mapping for a given key from the cache, if it is present. This occurs if and only if there is a mapping from key k to value v such that (key==null ? k==null : key.equals(k)). This method returns true if the removal was successful, or false if there was no such mapping.
        Parameters:
        key - the key whose mapping will be deleted
        Returns:
        returns true if successful, or false if there was no mapping
        Throws:
        NullPointerException - if the key is null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • remove

        io.reactivex.rxjava3.core.Single<Boolean> remove​(K key,
                                                 V oldValue)
        This method atomically removes a key's mapping only if it is currently mapped to the provided value.
        Parameters:
        key - the key whose mapping will be deleted
        oldValue - the value that should be mapped to the given key
        Returns:
        returns true if successful, or false if there was no such mapping
        Throws:
        NullPointerException - if the key is null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • getAndRemove

        io.reactivex.rxjava3.core.Maybe<V> getAndRemove​(K key)
        This method atomically removes the entry for a key only if it is currently mapped to some value.
        Parameters:
        key - the given key
        Returns:
        the value if it existed, or null if it did not
        Throws:
        NullPointerException - if the key is null.
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • replace

        io.reactivex.rxjava3.core.Single<Boolean> replace​(K key,
                                                  V oldValue,
                                                  V newValue)
        This method atomically replaces an entry only if the key is currently mapped to a given value.
        Parameters:
        key - the key associated with the given oldValue
        oldValue - the value that should be associated with the key
        newValue - the value that will be associated with the key
        Returns:
        true if the value was replaced, or false if not
        Throws:
        NullPointerException - if the key or values are null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • replace

        io.reactivex.rxjava3.core.Single<Boolean> replace​(K key,
                                                  V value)
        This method atomically replaces an entry only if the key is currently mapped to some value.
        Parameters:
        key - the key mapped to the given value
        value - the value mapped to the given key
        Returns:
        true if the value was replaced, or false if not
        Throws:
        NullPointerException - if the key or value is null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • getAndReplace

        io.reactivex.rxjava3.core.Maybe<V> getAndReplace​(K key,
                                                 V value)
        This method atomically replaces a given key's value if and only if the key is currently mapped to a value.
        Parameters:
        key - the key associated with the given value
        value - the value associated with the given key
        Returns:
        the previous value mapped to the given key, or null if there was no such mapping.
        Throws:
        NullPointerException - if the key or value is null
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • removeAll

        io.reactivex.rxjava3.core.Completable removeAll​(Set<? extends K> keys)
        This method deletes the entries for the given keys. The order in which the individual entries are removed is undefined. For every entry in the key set, the following are called: • any registered CacheEntryRemovedListeners • if the cache is a write-through cache, the CacheWriter If the key set is empty, the CacheWriter is not called.
        Parameters:
        keys - the keys to remove
        Returns:
        void
        Throws:
        NullPointerException - if keys is null or if it contains a null key
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache

      • clear

        io.reactivex.rxjava3.core.Completable clear()
        This method empties the cache's contents, without notifying listeners or CacheWriters.
        Returns:
        void
        Throws:
        IllegalStateException - if the cache is in a closed state
        javax.cache.CacheException - if there is a problem with the cache