Package org.dataloader.impl

Class DefaultCacheMap<K,V>

java.lang.Object
org.dataloader.impl.DefaultCacheMap<K,V>
Type Parameters:
K - type parameter indicating the type of the cache keys
V - type parameter indicating the type of the data that is cached
All Implemented Interfaces:
CacheMap<K,V>
@NullMarked public class DefaultCacheMap<K,V> extends Object implements CacheMap<K,V>
Default implementation of CacheMap that is based on a regular HashMap.

  • Constructor Details

    • DefaultCacheMap

      public DefaultCacheMap()
      Default constructor

  • Method Details

    • containsKey

      public boolean containsKey(K key)
      Checks whether the specified key is contained in the cache map.
      Specified by:
      containsKey in interface CacheMap<K,V>
      Parameters:
      key - the key to check
      Returns:
      true if the cache contains the key, false otherwise

    • get

      public @Nullable CompletableFuture<V> get(K key)
      Gets the specified key from the cache map.

      May throw an exception if the key does not exist, depending on the cache map implementation that is used.

      Specified by:
      get in interface CacheMap<K,V>
      Parameters:
      key - the key to retrieve
      Returns:
      the cached value, or null if not found (depends on cache implementation)

    • getAll

      public Collection<CompletableFuture<V>> getAll()
      Gets a collection of CompletableFutures from the cache map.
      Specified by:
      getAll in interface CacheMap<K,V>
      Returns:
      the collection of cached values

    • putIfAbsentAtomically

      public @Nullable CompletableFuture<V> putIfAbsentAtomically(K key, CompletableFuture<V> value)
      Atomically creates a new cache map entry with the specified key and value, or updates the value if the key already exists.

      The data loader code using a Compare and Swap (CAS) algorithm to decide if a cache entry is present or not. If you write your own CacheMap implementation then you MUST provide atomic writes in this method to ensure that the same promise for a key is returned always.

      The default implementation of this method uses ConcurrentHashMap has its implementation so these CAS writes work as expected.

      Specified by:
      putIfAbsentAtomically in interface CacheMap<K,V>
      Parameters:
      key - the key to cache
      value - the value to cache
      Returns:
      atomically the previous value for the key or null if the value is not present.

    • delete

      public CacheMap<K,V> delete(K key)
      Deletes the entry with the specified key from the cache map, if it exists.
      Specified by:
      delete in interface CacheMap<K,V>
      Parameters:
      key - the key to delete
      Returns:
      the cache map for fluent coding

    • clear

      public CacheMap<K,V> clear()
      Clears all entries of the cache map
      Specified by:
      clear in interface CacheMap<K,V>
      Returns:
      the cache map for fluent coding

    • size

      public int size()
      Description copied from interface: CacheMap
      Returns the current size of the cache. This is not used by DataLoader directly and intended for testing and debugging. If a cache doesn't support it, it can throw an Exception.
      Specified by:
      size in interface CacheMap<K,V>
      Returns:
      the size of the cache