Interface AdvancedCache<K,​V>

    • Method Detail

      • withFlags

        AdvancedCache<K,​V> withFlags​(Flag... flags)
        A method that adds flags to any API call. For example, consider the following code snippet:
           cache.withFlags(Flag.FORCE_WRITE_LOCK).get(key);
         
        will invoke a cache.get() with a write lock forced.

        Note that for the flag to take effect, the cache operation must be invoked on the instance returned by this method.

        As an alternative to setting this on every invocation, users should also consider saving the decorated cache, as this allows for more readable code. E.g.:

            AdvancedCache<?, ?> forceWriteLockCache = cache.withFlags(Flag.FORCE_WRITE_LOCK);
            forceWriteLockCache.get(key1);
            forceWriteLockCache.get(key2);
            forceWriteLockCache.get(key3);
         
        Parameters:
        flags - a set of flags to apply. See the Flag documentation.
        Returns:
        an AdvancedCache instance on which a real operation is to be invoked, if the flags are to be applied.
      • transform

        default AdvancedCache<K,​V> transform​(Function<AdvancedCache<K,​V>,​? extends AdvancedCache<K,​V>> transformation)
        Apply the transformation on each AdvancedCache instance in a delegation chain, starting with the innermost implementation.
        Parameters:
        transformation -
        Returns:
        The outermost transformed cache.
      • getAsyncInterceptorChain

        @Deprecated
        AsyncInterceptorChain getAsyncInterceptorChain()
        Deprecated.
        Since 10.0, will be removed without a replacement
        Allows the modification of the interceptor chain.
      • getEvictionManager

        @Deprecated
        EvictionManager getEvictionManager()
        Deprecated.
        Since 10.1, will be removed without a replacement
        Returns:
        the eviction manager - if one is configured - for this cache instance
      • getExpirationManager

        ExpirationManager<K,​V> getExpirationManager()
        Returns:
        the expiration manager - if one is configured - for this cache instance
      • getComponentRegistry

        @Deprecated
        ComponentRegistry getComponentRegistry()
        Deprecated.
        Since 10.0, with no public API replacement
        Returns:
        the component registry for this cache instance
      • getDistributionManager

        DistributionManager getDistributionManager()
        Retrieves a reference to the DistributionManager if the cache is configured to use Distribution. Otherwise, returns a null.
        Returns:
        a DistributionManager, or null.
      • getAuthorizationManager

        AuthorizationManager getAuthorizationManager()
        Retrieves the AuthorizationManager if the cache has security enabled. Otherwise returns null
        Returns:
        an AuthorizationManager or null
      • lockAs

        AdvancedCache<K,​V> lockAs​(Object lockOwner)
        Whenever this cache acquires a lock it will do so using the given Object as the owner of said lock.

        This can be useful when a lock may have been manually acquired and you wish to reuse that lock across invocations.

        Great care should be taken with this command as misuse can very easily lead to deadlocks.

        Parameters:
        lockOwner - the lock owner to lock any keys as
        Returns:
        an AdvancedCache instance on which when an operation is invoked it will use lock owner object to acquire any locks
      • lock

        boolean lock​(K... keys)
        Locks a given key or keys eagerly across cache nodes in a cluster.

        Keys can be locked eagerly in the context of a transaction only.

        Parameters:
        keys - the keys to lock
        Returns:
        true if the lock acquisition attempt was successful for all keys; false will only be returned if the lock acquisition timed out and the operation has been called with Flag.FAIL_SILENTLY.
        Throws:
        TimeoutException - if the lock cannot be acquired within the configured lock acquisition time.
      • lock

        boolean lock​(Collection<? extends K> keys)
        Locks collections of keys eagerly across cache nodes in a cluster.

        Collections of keys can be locked eagerly in the context of a transaction only.

        Parameters:
        keys - collection of keys to lock
        Returns:
        true if the lock acquisition attempt was successful for all keys; false will only be returned if the lock acquisition timed out and the operation has been called with Flag.FAIL_SILENTLY.
        Throws:
        TimeoutException - if the lock cannot be acquired within the configured lock acquisition time.
      • getRpcManager

        RpcManager getRpcManager()
        Returns the component in charge of communication with other caches in the cluster. If the cache's ClusteringConfiguration.cacheMode() is CacheMode.LOCAL, this method will return null.
        Returns:
        the RPC manager component associated with this cache instance or null
      • getBatchContainer

        BatchContainer getBatchContainer()
        Returns the component in charge of batching cache operations.
        Returns:
        the batching component associated with this cache instance
      • getDataContainer

        DataContainer<K,​V> getDataContainer()
        Returns the container where data is stored in the cache. Users should interact with this component with care because direct calls on it bypass the internal interceptors and other infrastructure in place to guarantee the consistency of data.
        Returns:
        the data container associated with this cache instance
      • getLockManager

        LockManager getLockManager()
        Returns the component that deals with all aspects of acquiring and releasing locks for cache entries.
        Returns:
        retrieves the lock manager associated with this cache instance
      • getStats

        Stats getStats()
        Returns a Stats object that allows several statistics associated with this cache at runtime.
        Returns:
        this cache's Stats object
      • getXAResource

        XAResource getXAResource()
        Returns the XAResource associated with this cache which can be used to do transactional recovery.
        Returns:
        an instance of XAResource
      • getClassLoader

        ClassLoader getClassLoader()
        Returns the cache loader associated associated with this cache. As an alternative to setting this on every invocation, users could also consider using the DecoratedCache wrapper.
        Returns:
        this cache's cache loader
      • put

        V put​(K key,
              V value,
              Metadata metadata)
        An overloaded form of #put(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc.
        Parameters:
        key - key to use
        value - value to store
        metadata - information to store alongside the value
        Returns:
        the previous value associated with key, or null if there was no mapping for key.
        Since:
        5.3
      • putAll

        void putAll​(Map<? extends K,​? extends V> map,
                    Metadata metadata)
        An overloaded form of Map.putAll(Map), which takes in an instance of Metadata which can be used to provide metadata information for the entries being stored, such as lifespan, version of value...etc.
        Parameters:
        map - the values to store
        metadata - information to store alongside the value(s)
        Since:
        7.2
      • replace

        V replace​(K key,
                  V value,
                  Metadata metadata)
        An overloaded form of #replace(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is associated
        value - value to be associated with the specified key
        metadata - information to store alongside the new value
        Returns:
        the previous value associated with the specified key, or null if there was no mapping for the key.
        Since:
        5.3
      • replaceAsync

        default CompletableFuture<V> replaceAsync​(K key,
                                                  V value,
                                                  Metadata metadata)
        An overloaded form of #replaceAsync(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is associated
        value - value to be associated with the specified key
        metadata - information to store alongside the new value
        Returns:
        the future that contains previous value associated with the specified key, or null if there was no mapping for the key.
        Since:
        9.2
      • replaceAsyncEntry

        CompletableFuture<CacheEntry<K,​V>> replaceAsyncEntry​(K key,
                                                                   V value,
                                                                   Metadata metadata)
        An extension of #replaceAsync(K, V, Metadata), which returns a CacheEntry instead of only the value.
        Parameters:
        key - key with which the specified value is associated
        value - value to be associated with the specified key
        metadata - information to store alongside the new value
        Returns:
        the future that contains previous CacheEntry associated with the specified key, or null if there was no mapping for the key.
        Since:
        14.0
        See Also:
        #replaceAsync(K, V, Metadata)
      • replace

        boolean replace​(K key,
                        V oldValue,
                        V newValue,
                        Metadata metadata)
        An overloaded form of #replace(K, V, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is associated
        oldValue - value expected to be associated with the specified key
        newValue - value to be associated with the specified key
        metadata - information to store alongside the new value
        Returns:
        true if the value was replaced
        Since:
        5.3
      • putIfAbsent

        V putIfAbsent​(K key,
                      V value,
                      Metadata metadata)
        An overloaded form of #putIfAbsent(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is to be associated
        value - value to be associated with the specified key
        metadata - information to store alongside the new value
        Returns:
        the previous value associated with the specified key, or null if there was no mapping for the key.
        Since:
        5.3
      • putIfAbsentAsync

        default CompletableFuture<V> putIfAbsentAsync​(K key,
                                                      V value,
                                                      Metadata metadata)
        An overloaded form of #putIfAbsentAsync(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is to be associated
        value - value to be associated with the specified key
        metadata - information to store alongside the new value
        Returns:
        A future containing the previous value associated with the specified key, or null if there was no mapping for the key.
        Since:
        9.2
      • putIfAbsentAsyncEntry

        CompletableFuture<CacheEntry<K,​V>> putIfAbsentAsyncEntry​(K key,
                                                                       V value,
                                                                       Metadata metadata)
        An extension form of #putIfAbsentAsync(K, V, Metadata), which returns a CacheEntry instead of only the value.
        Parameters:
        key - key with which the specified value is to be associated
        value - value to be associated with the specified key
        metadata - information to store alongside the new value
        Returns:
        the future that contains previous CacheEntry associated with the specified key, or null if there was no mapping for the key.
        Since:
        14.0
        See Also:
        #putIfAbsentAsync(K, V, Metadata)
      • putForExternalRead

        void putForExternalRead​(K key,
                                V value,
                                Metadata metadata)
        An overloaded form of #putForExternalRead(K, V), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is to be associated
        value - value to be associated with the specified key
        metadata - information to store alongside the new value
        Since:
        7.0
      • compute

        V compute​(K key,
                  BiFunction<? super K,​? super V,​? extends V> remappingFunction,
                  Metadata metadata)
        An overloaded form of #compute(K, BiFunction), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc.
        Parameters:
        key - key with which the specified value is associated
        remappingFunction - function to be applied to the specified key/value
        metadata - information to store alongside the new value
        Returns:
        the previous value associated with the specified key, or null if remapping function is gives null.
        Since:
        9.1
      • computeIfPresent

        V computeIfPresent​(K key,
                           BiFunction<? super K,​? super V,​? extends V> remappingFunction,
                           Metadata metadata)
        An overloaded form of #computeIfPresent(K, BiFunction), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is associated
        remappingFunction - function to be applied to the specified key/value
        metadata - information to store alongside the new value
        Returns:
        the previous value associated with the specified key, or null if there was no mapping for the key.
        Since:
        9.1
      • computeIfAbsent

        V computeIfAbsent​(K key,
                          Function<? super K,​? extends V> mappingFunction,
                          Metadata metadata)
        An overloaded form of #computeIfAbsent(K, Function), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is associated
        mappingFunction - function to be applied to the specified key
        metadata - information to store alongside the new value
        Returns:
        the value created with the mapping function associated with the specified key, or the previous value associated with the specified key if the key is not absent.
        Since:
        9.1
      • merge

        V merge​(K key,
                V value,
                BiFunction<? super V,​? super V,​? extends V> remappingFunction,
                Metadata metadata)
        An overloaded form of Cache.merge(Object, Object, BiFunction), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - , key with which the resulting value is to be associated
        value - , the non-null value to be merged with the existing value associated with the key or, if no existing value or a null value is associated with the key, to be associated with the key
        remappingFunction - , the function to recompute a value if present
        metadata - , information to store alongside the new value
        Returns:
        the new value associated with the specified key, or null if no value is associated with the key
        Since:
        9.2
      • putAsync

        CompletableFuture<V> putAsync​(K key,
                                      V value,
                                      Metadata metadata)
        Asynchronous version of put(Object, Object, Metadata) which stores metadata alongside the value. This method does not block on remote calls, even if your cache mode is synchronous. Has no benefit over put(Object, Object, Metadata) if used in LOCAL mode.

        Parameters:
        key - key to use
        value - value to store
        metadata - information to store alongside the new value
        Returns:
        a future containing the old value replaced.
        Since:
        5.3
      • putAsyncEntry

        CompletableFuture<CacheEntry<K,​V>> putAsyncEntry​(K key,
                                                               V value,
                                                               Metadata metadata)
        Extension of #putAsync(K, V, Metadata) which returns a CacheEntry instead of only the previous value.
        Parameters:
        key - key to use
        value - value to store
        metadata - information to store alongside the new value
        Returns:
        a future containing the old CacheEntry replaced.
        Since:
        14.0
      • computeAsync

        CompletableFuture<V> computeAsync​(K key,
                                          BiFunction<? super K,​? super V,​? extends V> remappingFunction,
                                          Metadata metadata)
        Overloaded #computeAsync(K, BiFunction), which stores metadata alongside the value. This method does not block on remote calls, even if your cache mode is synchronous.
        Parameters:
        key - key with which the specified value is associated
        remappingFunction - function to be applied to the specified key/value
        metadata - information to store alongside the new value
        Returns:
        the previous value associated with the specified key, or null if remapping function is gives null.
        Since:
        9.4
      • computeIfPresentAsync

        CompletableFuture<V> computeIfPresentAsync​(K key,
                                                   BiFunction<? super K,​? super V,​? extends V> remappingFunction,
                                                   Metadata metadata)
        Overloaded #computeIfPresentAsync(K, BiFunction), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is associated
        remappingFunction - function to be applied to the specified key/value
        metadata - information to store alongside the new value
        Returns:
        the previous value associated with the specified key, or null if there was no mapping for the key.
        Since:
        9.4
      • computeIfAbsentAsync

        CompletableFuture<V> computeIfAbsentAsync​(K key,
                                                  Function<? super K,​? extends V> mappingFunction,
                                                  Metadata metadata)
        Overloaded #computeIfAbsentAsync(K, Function), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - key with which the specified value is associated
        mappingFunction - function to be applied to the specified key
        metadata - information to store alongside the new value
        Returns:
        the value created with the mapping function associated with the specified key, or the previous value associated with the specified key if the key is not absent.
        Since:
        9.4
      • mergeAsync

        CompletableFuture<V> mergeAsync​(K key,
                                        V value,
                                        BiFunction<? super V,​? super V,​? extends V> remappingFunction,
                                        Metadata metadata)
        Overloaded AsyncCache.mergeAsync(Object, Object, BiFunction), which takes in an instance of Metadata which can be used to provide metadata information for the entry being stored, such as lifespan, version of value...etc. The Metadata is only stored if the call is successful.
        Parameters:
        key - , key with which the resulting value is to be associated
        value - , the non-null value to be merged with the existing value associated with the key or, if no existing value or a null value is associated with the key, to be associated with the key
        remappingFunction - , the function to recompute a value if present
        metadata - , information to store alongside the new value
        Returns:
        the new value associated with the specified key, or null if no value is associated with the key
        Since:
        9.4
      • getAll

        Map<K,​V> getAll​(Set<?> keys)
        Gets a collection of entries, returning them as Map of the values associated with the set of keys requested.

        If the cache is configured read-through, and a get for a key would return null because an entry is missing from the cache, the Cache's CacheLoader is called in an attempt to load the entry. If an entry cannot be loaded for a given key, the returned Map will contain null for value of the key.

        Unlike other bulk methods if this invoked in an existing transaction all entries will be stored in the current transactional context

        The returned Map will be a copy and updates to the map will not be reflected in the Cache and vice versa. The keys and values themselves however may not be copies depending on if storeAsBinary is enabled and the value was retrieved from the local node.

        Parameters:
        keys - The keys whose associated values are to be returned.
        Returns:
        A map of entries that were found for the given keys. If an entry is not found for a given key, it will not be in the returned map.
        Throws:
        NullPointerException - if keys is null or if keys contains a null
      • getCacheEntry

        CacheEntry<K,​V> getCacheEntry​(Object key)
        Retrieves a CacheEntry corresponding to a specific key.
        Parameters:
        key - the key whose associated cache entry is to be returned
        Returns:
        the cache entry to which the specified key is mapped, or null if this map contains no mapping for the key
        Since:
        5.3
      • getCacheEntryAsync

        default CompletableFuture<CacheEntry<K,​V>> getCacheEntryAsync​(Object key)
        Retrieves a CacheEntry corresponding to a specific key.
        Parameters:
        key - the key whose associated cache entry is to be returned
        Returns:
        a future with the cache entry to which the specified key is mapped, or with null if this map contains no mapping for the key
        Since:
        9.2
      • getAllCacheEntries

        Map<K,​CacheEntry<K,​V>> getAllCacheEntries​(Set<?> keys)
        Gets a collection of entries from the AdvancedCache, returning them as Map of the cache entries associated with the set of keys requested.

        If the cache is configured read-through, and a get for a key would return null because an entry is missing from the cache, the Cache's CacheLoader is called in an attempt to load the entry. If an entry cannot be loaded for a given key, the returned Map will contain null for value of the key.

        Unlike other bulk methods if this invoked in an existing transaction all entries will be stored in the current transactional context

        The returned Map will be a copy and updates to the map will not be reflected in the Cache and vice versa. The keys and values themselves however may not be copies depending on if storeAsBinary is enabled and the value was retrieved from the local node.

        Parameters:
        keys - The keys whose associated values are to be returned.
        Returns:
        A map of entries that were found for the given keys. Keys not found in the cache are present in the map with null values.
        Throws:
        NullPointerException - if keys is null or if keys contains a null
      • getAndPutAll

        default Map<K,​V> getAndPutAll​(Map<? extends K,​? extends V> map)
        Executes an equivalent of Map.putAll(Map), returning previous values of the modified entries.
        Parameters:
        map - mappings to be stored in this map
        Returns:
        A map of previous values for the given keys. If the previous mapping does not exist it will not be in the returned map.
        Since:
        9.1
      • getGroup

        Map<K,​V> getGroup​(String groupName)
        It fetches all the keys which belong to the group.

        Semantically, it iterates over all the keys in memory and persistence, and performs a read operation in the keys found. Multiple invocations inside a transaction ensures that all the keys previous read are returned and it may return newly added keys to the group from other committed transactions (also known as phantom reads).

        The map returned is immutable and represents the group at the time of the invocation. If you want to add or remove keys from a group use BasicCache.put(Object, Object) and BasicCache.remove(Object). To remove all the keys in the group use removeGroup(String).

        To improve performance you may use the flag Flag.SKIP_CACHE_LOAD to avoid fetching the key/value from persistence. However, you will get an inconsistent snapshot of the group.

        Parameters:
        groupName - the group name.
        Returns:
        an immutable Map with the key/value pairs.
      • removeGroup

        void removeGroup​(String groupName)
        It removes all the key which belongs to a group.

        Semantically, it fetches the most recent group keys/values and removes them.

        Note that, concurrent addition perform by other transactions/threads to the group may not be removed.

        Parameters:
        groupName - the group name.
      • touch

        CompletionStage<Boolean> touch​(Object key,
                                       boolean touchEvenIfExpired)
        Touches the given key if present. This will refresh its last access time, used for max idle, and count as a recent access for eviction purposes.

        Note that it is possible to touch an entry that is expired via max idle if touchEvenIfExpired argument is true.

        This method will return without blocking and complete the returned stage with a value after all appropriate nodes have actually touched the value.

        Parameters:
        key - key of the entry to touch
        touchEvenIfExpired - true if the entry should be touched even if already expired via max idle, effectively making it so the entry is no longer expired via max idle
        Returns:
        true if the entry was actually touched
      • touch

        CompletionStage<Boolean> touch​(Object key,
                                       int segment,
                                       boolean touchEvenIfExpired)
        The same as touch(Object, boolean) except that the segment is already known. This can be helpful to reduce an extra segment computation
        Parameters:
        key - key of the entry to touch
        segment - segment of the key
        touchEvenIfExpired - true if the entry should be touched even if already expired via max idle, effectively making it so the entry is no longer expired via max idle
        Returns:
        true if the entry was actually touched
      • cacheEntrySet

        CacheSet<CacheEntry<K,​V>> cacheEntrySet()
        Identical to Cache.entrySet() but is typed to return CacheEntries instead of Entries. Please see the other method for a description of its behaviors.

        This method is needed since nested generics do not support covariance

        Returns:
        the entry set containing all of the CacheEntries
        See Also:
        Cache.entrySet()
      • lockedStream

        LockedStream<K,​V> lockedStream()
        Returns a sequential stream using this Cache as the source. This stream is very similar to using the CacheStream returned from the CacheCollection.stream() method of the collection returned via cacheEntrySet(). The use of this locked stream is that when an entry is being processed by the user the entry is locked for the invocation preventing a different thread from modifying it.

        Note that this stream is not supported when using a optimistic transactional or simple cache. Both non transactional and pessimistic transactional caches are supported.

        The stream will not share any ongoing transaction the user may have. Code executed by the stream should be treated as completely independent. That is any operation performed via the stream will require the user to start their own transaction or will be done intrinsically on the invocation. Note that if there is an ongoing transaction that has a lock on a key from the cache, that it will cause a deadlock.

        Currently simple cache, ConfigurationBuilder.simpleCache(boolean) was set to true, and optimistic caches, TransactionConfigurationBuilder.lockingMode(LockingMode) was set to LockingMode.OPTIMISTIC, do not support this method. In this case it will throw an UnsupportedOperationException. This restriction may be removed in a future version. Also this method cannot be used on a cache that has a lock owner already specified via lockAs(Object) as this could lead to a deadlock or the release of locks early and will throw an IllegalStateException.

        Returns:
        the locked stream
        Throws:
        UnsupportedOperationException - this is thrown if invoked from a cache that doesn't support this
        IllegalStateException - if this cache has already explicitly set a lock owner
        Since:
        9.1
      • removeLifespanExpired

        CompletableFuture<Boolean> removeLifespanExpired​(K key,
                                                         V value,
                                                         Long lifespan)
        Attempts to remove the entry if it is expired. Due to expired entries not being consistent across nodes, this will still attempt to remove the value if it is not present. Note that this will raise an expired event even if the entry is not present. Normally this method should never be invoked except by the ExpirationManager.

        This command will only remove the value if the value and lifespan also match if provided.

        This method will suspend any ongoing transaction and start a new one just for the invocation of this command. It is automatically committed or rolled back after the command completes, either successfully or via an exception.

        NOTE: This method may be removed at any point including in a minor release and is not supported for external usage.

        Parameters:
        key - the key that is expiring
        value - the value that mapped to the given. Null means it will match any value
        lifespan - the lifespan that should match. If null is provided it will match any lifespan value
        Returns:
        if the entry was removed
      • removeMaxIdleExpired

        CompletableFuture<Boolean> removeMaxIdleExpired​(K key,
                                                        V value)
        Attempts to remove the entry for the given key, if it has expired due to max idle. This command first locks the key and then verifies that the entry has expired via maxIdle across all nodes. If it has this will then remove the given key.

        This method returns a boolean when it has determined if the entry has expired. This is useful for when a backup node invokes this command for a get that found the entry expired. This way the node can return back to the caller much faster when the entry is not expired and do any additional processing asynchronously if needed.

        This method will suspend any ongoing transaction and start a new one just for the invocation of this command. It is automatically committed or rolled back after the command completes, either successfully or via an exception.

        NOTE: This method may be removed at any point including in a minor release and is not supported for external usage.

        Parameters:
        key - the key that expired via max idle for the given entry
        Returns:
        if the entry was removed
      • withEncoding

        @Deprecated
        AdvancedCache<?,​?> withEncoding​(Class<? extends Encoder> keyEncoder,
                                              Class<? extends Encoder> valueEncoder)
        Deprecated.
        Since 12.1, to be removed in a future version.
        Performs any cache operations using the specified pair of Encoder.
        Parameters:
        keyEncoder - Encoder for the keys.
        valueEncoder - Encoder for the values.
        Returns:
        an instance of AdvancedCache where all operations will use the supplied encoders.
      • withWrapping

        AdvancedCache<K,​V> withWrapping​(Class<? extends Wrapper> keyWrapper,
                                              Class<? extends Wrapper> valueWrapper)
        Deprecated.
        Since 11.0. To be removed in 14.0, with no replacement.
        Performs any cache operations using the specified pair of Wrapper.
        Parameters:
        keyWrapper - Wrapper for the keys.
        valueWrapper - Wrapper for the values.
        Returns:
        AdvancedCache where all operations will use the supplied wrappers.
      • withEncoding

        @Deprecated
        AdvancedCache<?,​?> withEncoding​(Class<? extends Encoder> encoder)
        Deprecated.
        Since 12.1, to be removed in a future version.
        Performs any cache operations using the specified Encoder.
        Parameters:
        encoder - Encoder used for both keys and values.
        Returns:
        an instance of AdvancedCache where all operations will use the supplied encoder.
      • withWrapping

        AdvancedCache<K,​V> withWrapping​(Class<? extends Wrapper> wrapper)
        Deprecated.
        Since 11.0. To be removed in 14.0, with no replacement.
        Performs any cache operations using the specified Wrapper.
        Parameters:
        wrapper - Wrapper for the keys and values.
        Returns:
        an instance of AdvancedCache where all operations will use the supplied wrapper.
      • withStorageMediaType

        AdvancedCache<K,​V> withStorageMediaType()
        Perform any cache operations using the same MediaType of the cache storage. This is equivalent to disabling transcoding on the cache.
        Returns:
        an instance of AdvancedCache where no data conversion will take place.