memoization

Type Members

class Macros extends AnyRef
case class MemoizationConfig(toStringConverter: MethodCallToStringConverter = ...) extends Product with Serializable

Configuration related to the behaviour of the scalacache.memoization.memoize{Sync} methods.
Configuration related to the behaviour of the scalacache.memoization.memoize{Sync} methods.
toStringConverter
converter for generating a String cache key from information about a method call
trait MethodCallToStringConverter extends AnyRef

Converts information about a method call to a String for use in a cache key
final class cacheKeyExclude extends Annotation with StaticAnnotation

Add this annotation to method or class constructor parameters in order to exclude them from auto-generated cache keys.
Add this annotation to method or class constructor parameters in order to exclude them from auto-generated cache keys.
e.g.
```
def foo(a: Int, @cacheKeyExclude b: String, c: String): Int = memoize { ... }
```
will not include the value of the b parameter in its cache keys.

Value Members

object MethodCallToStringConverter
macro def memoize[A](optionalTtl: Option[Duration])(f: ⇒ Future[A])(implicit scalaCache: ScalaCache, flags: Flags, ec: ExecutionContext): Future[A]

Perform the given operation and memoize its result to a cache before returning it.
Perform the given operation and memoize its result to a cache before returning it. If the result is already in the cache, return it without performing the operation.
All of the above happens asynchronously, so a Future is returned immediately. Specifically: - when the cache lookup completes, if it is a miss, the function execution is started. - at some point after the function completes, the result is written asynchronously to the cache. - the Future returned from this method does not wait for the cache write before completing.
The result is stored in the cache with the given TTL. It will be evicted when the TTL is up.
Note that if the result is currently in the cache, changing the TTL has no effect. TTL is only set once, when the result is added to the cache.
A
type of the value to be cached
optionalTtl
Optional Time to Live. If defined, how long the result should be stored in the cache.
f
function that returns some result. This result is the value that will be cached.
scalaCache
cache configuration
flags
flags to customize ScalaCache behaviour
returns
the result, either retrieved from the cache or calculated by executing the function f
macro def memoize[A](ttl: Duration)(f: ⇒ Future[A])(implicit scalaCache: ScalaCache, flags: Flags, ec: ExecutionContext): Future[A]

Perform the given operation and memoize its result to a cache before returning it.
Perform the given operation and memoize its result to a cache before returning it. If the result is already in the cache, return it without performing the operation.
All of the above happens asynchronously, so a Future is returned immediately. Specifically: - when the cache lookup completes, if it is a miss, the function execution is started. - at some point after the function completes, the result is written asynchronously to the cache. - the Future returned from this method does not wait for the cache write before completing.
The result is stored in the cache with the given TTL. It will be evicted when the TTL is up.
Note that if the result is currently in the cache, changing the TTL has no effect. TTL is only set once, when the result is added to the cache.
A
type of the value to be cached
ttl
Time To Live. How long the result should be stored in the cache.
f
function that asynchronously returns some result. This result is the value that will be cached.
scalaCache
cache configuration
flags
flags to customize ScalaCache behaviour
ec
An ExecutionContext in which to execute operations on Futures
returns
a Future of the result, either retrieved from the cache or calculated by executing the function f
macro def memoize[A](f: ⇒ Future[A])(implicit scalaCache: ScalaCache, flags: Flags, ec: ExecutionContext): Future[A]

Perform the given operation and memoize its result to a cache before returning it.
Perform the given operation and memoize its result to a cache before returning it. If the result is already in the cache, return it without performing the operation.
All of the above happens asynchronously, so a Future is returned immediately. Specifically: - when the cache lookup completes, if it is a miss, the function execution is started. - at some point after the function completes, the result is written asynchronously to the cache. - the Future returned from this method does not wait for the cache write before completing.
The result is stored in the cache without a TTL, so it will remain until it is naturally evicted.
A
type of the value to be cached
f
function that asynchronously returns some result. This result is the value that will be cached.
scalaCache
cache configuration
flags
flags to customize ScalaCache behaviour
ec
An ExecutionContext in which to execute operations on Futures
returns
a Future of the result, either retrieved from the cache or calculated by executing the function f
macro def memoizeSync[A](optionalTtl: Option[Duration])(f: ⇒ A)(implicit scalaCache: ScalaCache, flags: Flags): A

Perform the given operation and memoize its result to a cache before returning it.
Perform the given operation and memoize its result to a cache before returning it. If the result is already in the cache, return it without performing the operation.
The result is stored in the cache with the given TTL. It will be evicted when the TTL is up.
Note that if the result is currently in the cache, changing the TTL has no effect. TTL is only set once, when the result is added to the cache.
Warning: may block indefinitely!
A
type of the value to be cached
optionalTtl
Optional Time to Live. If defined, how long the result should be stored in the cache.
f
function that returns some result. This result is the value that will be cached.
scalaCache
cache configuration
flags
flags to customize ScalaCache behaviour
returns
the result, either retrieved from the cache or calculated by executing the function f
macro def memoizeSync[A](ttl: Duration)(f: ⇒ A)(implicit scalaCache: ScalaCache, flags: Flags): A

Perform the given operation and memoize its result to a cache before returning it.
Perform the given operation and memoize its result to a cache before returning it. If the result is already in the cache, return it without performing the operation.
The result is stored in the cache with the given TTL. It will be evicted when the TTL is up.
Note that if the result is currently in the cache, changing the TTL has no effect. TTL is only set once, when the result is added to the cache.
Warning: may block indefinitely!
A
type of the value to be cached
ttl
Time To Live. How long the result should be stored in the cache.
f
function that returns some result. This result is the value that will be cached.
scalaCache
cache configuration
flags
flags to customize ScalaCache behaviour
returns
the result, either retrieved from the cache or calculated by executing the function f
macro def memoizeSync[A](f: ⇒ A)(implicit scalaCache: ScalaCache, flags: Flags): A

Perform the given operation and memoize its result to a cache before returning it.
Perform the given operation and memoize its result to a cache before returning it. If the result is already in the cache, return it without performing the operation.
The result is stored in the cache without a TTL, so it will remain until it is naturally evicted.
Warning: may block indefinitely!
A
type of the value to be cached
f
function that returns some result. This result is the value that will be cached.
scalaCache
cache configuration
flags
flags to customize ScalaCache behaviour
returns
the result, either retrieved from the cache or calculated by executing the function f

package memoization

Type Members

class Macros extends AnyRef

case class MemoizationConfig(toStringConverter: MethodCallToStringConverter = ...) extends Product with Serializable

trait MethodCallToStringConverter extends AnyRef

final class cacheKeyExclude extends Annotation with StaticAnnotation

Value Members

object MethodCallToStringConverter

macro def memoize[A](optionalTtl: Option[Duration])(f: ⇒ Future[A])(implicit scalaCache: ScalaCache, flags: Flags, ec: ExecutionContext): Future[A]

macro def memoize[A](ttl: Duration)(f: ⇒ Future[A])(implicit scalaCache: ScalaCache, flags: Flags, ec: ExecutionContext): Future[A]

macro def memoize[A](f: ⇒ Future[A])(implicit scalaCache: ScalaCache, flags: Flags, ec: ExecutionContext): Future[A]

macro def memoizeSync[A](optionalTtl: Option[Duration])(f: ⇒ A)(implicit scalaCache: ScalaCache, flags: Flags): A

macro def memoizeSync[A](ttl: Duration)(f: ⇒ A)(implicit scalaCache: ScalaCache, flags: Flags): A

macro def memoizeSync[A](f: ⇒ A)(implicit scalaCache: ScalaCache, flags: Flags): A

Inherited from AnyRef

Inherited from Any

Ungrouped