com.github.blemale.scaffeine.LoadingCache.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scaffeine_2.12 Show documentation
Thin Scala wrapper for Caffeine.
The newest version!
package com.github.blemale.scaffeine

import com.github.benmanes.caffeine.cache.{LoadingCache => CaffeineLoadingCache}

import scala.collection.JavaConverters._
import scala.compat.java8.FutureConverters._
import scala.concurrent.Future

object LoadingCache {

  def apply[K, V](
      loadingCache: CaffeineLoadingCache[K, V]
  ): LoadingCache[K, V] =
    new LoadingCache(loadingCache)

}

class LoadingCache[K, V](override val underlying: CaffeineLoadingCache[K, V])
    extends Cache(underlying) {

  /** Returns the value associated with `key` in this cache, obtaining that
    * value from `loader` if necessary.  If another call to this method is
    * currently loading the value for `key`, this thread simply waits for that
    * thread to finish and returns its loaded value. Note that multiple threads
    * can concurrently load values for distinct keys.
    *
    * @param key
    *   key with which the specified value is to be associated
    * @return
    *   the current (existing or computed) value associated with the specified
    *   key
    * @throws java.lang.IllegalArgumentException
    *   if the computation detectably attempts a recursive update to this cache
    *   that would otherwise never complete
    * @throws java.util.concurrent.CompletionException
    *   if a checked exception was thrown while loading the value
    * @throws java.lang.RuntimeException
    *   or Error if the `CacheLoader` does so, in which case the mapping is left
    *   unestablished
    */
  def get(key: K): V =
    underlying.get(key)

  /** Returns a map of the values associated with `keys`, creating or retrieving
    * those values if necessary. The returned map contains entries that were
    * already cached, combined with newly loaded entries.
    *
    * @param keys
    *   the keys whose associated values are to be returned
    * @return
    *   the mapping of keys to values for the specified keys in this cache
    * @throws java.util.concurrent.CompletionException
    *   if a checked exception was thrown while loading the value
    * @throws java.lang.RuntimeException
    *   or Error if the `loader` does so
    */
  def getAll(keys: Iterable[K]): Map[K, V] =
    underlying.getAll(keys.asJava).asScala.toMap

  /** Loads a new value for the `key`, asynchronously. While the new value is
    * loading the previous value (if any) will continue to be returned by
    * `get(key)` unless it is evicted.
    *
    * @param key
    *   key with which a value may be associated
    */
  def refresh(key: K): Future[V] =
    underlying.refresh(key).toScala

  override def toString = s"LoadingCache($underlying)"
}