clojure.core.cache

Liking cljdoc? Tell your friends :D

Clojure only.

basic-cache-factory
CacheProtocol
evict
has?
hit
lookup
miss
seed
clear-soft-cache!
defcache
fifo-cache-factory
lirs-cache-factory
lru-cache-factory
lu-cache-factory
make-reference
soft-cache-factory
through
through-cache
ttl-cache-factory

A caching library for Clojure.

A caching library for Clojure.

raw docstring

basic-cache-factory^clj

(basic-cache-factory base)

Returns a pluggable basic cache initialized to base

Returns a pluggable basic cache initialized to `base`

source raw docstring

CacheProtocol^cljprotocol

This is the protocol describing the basic cache capability.

This is the protocol describing the basic cache capability.

evict^clj

(evict cache e)

Removes an entry from the cache

Removes an entry from the cache

has?^clj

(has? cache e)

Checks if the cache contains a value associated with e

Checks if the cache contains a value associated with `e`

hit^clj

(hit cache e)

Is meant to be called if the cache is determined to contain a value associated with e

Is meant to be called if the cache is determined to contain a value
associated with `e`

lookup^clj

(lookup cache e)

(lookup cache e not-found)

Retrieve the value associated with e if it exists, else nil in the 2-arg case. Retrieve the value associated with e if it exists, else not-found in the 3-arg case.

Retrieve the value associated with `e` if it exists, else `nil` in
the 2-arg case.  Retrieve the value associated with `e` if it exists,
else `not-found` in the 3-arg case.

miss^clj

(miss cache e ret)

Is meant to be called if the cache is determined to not contain a value associated with e

Is meant to be called if the cache is determined to **not** contain a
value associated with `e`

seed^clj

(seed cache base)

Is used to signal that the cache should be created with a seed. The contract is that said cache should return an instance of its own type.

Is used to signal that the cache should be created with a seed.
The contract is that said cache should return an instance of its
own type.

source

fifo-cache-factory^clj

(fifo-cache-factory base & {threshold :threshold :or {threshold 32}})

Returns a FIFO cache with the cache and FIFO queue initialized to base -- the queue is filled as the values are pulled out of base. If the associative structure can guarantee ordering, then the said ordering will define the eventual eviction order. Otherwise, there are no guarantees for the eventual eviction ordering.

This function takes an optional :threshold argument that defines the maximum number of elements in the cache before the FIFO semantics apply (default is 32).

If the number of elements in base is greater than the limit then some items in base will be dropped from the resulting cache. If the associative structure used as base can guarantee sorting, then the last limit elements will be used as the cache seed values. Otherwise, there are no guarantees about the elements in the resulting cache.

Returns a FIFO cache with the cache and FIFO queue initialized to `base` --
the queue is filled as the values are pulled out of `base`.  If the associative
structure can guarantee ordering, then the said ordering will define the
eventual eviction order.  Otherwise, there are no guarantees for the eventual
eviction ordering.

This function takes an optional `:threshold` argument that defines the maximum number
of elements in the cache before the FIFO semantics apply (default is 32).

If the number of elements in `base` is greater than the limit then some items
in `base` will be dropped from the resulting cache.  If the associative
structure used as `base` can guarantee sorting, then the last `limit` elements
will be used as the cache seed values.  Otherwise, there are no guarantees about
the elements in the resulting cache.

source raw docstring

lirs-cache-factory^clj

(lirs-cache-factory base
                    &
                    {:keys [s-history-limit q-history-limit]
                     :or {s-history-limit 32 q-history-limit 32}})

Returns an LIRS cache with the S & R LRU lists set to the indicated limits.

Returns an LIRS cache with the S & R LRU lists set to the indicated
limits.

source raw docstring

lru-cache-factory^clj

(lru-cache-factory base & {threshold :threshold :or {threshold 32}})

Returns an LRU cache with the cache and usage-table initialized to base -- each entry is initialized with the same usage value.

This function takes an optional :threshold argument that defines the maximum number of elements in the cache before the LRU semantics apply (default is 32).

Returns an LRU cache with the cache and usage-table initialized to `base` --
each entry is initialized with the same usage value.

This function takes an optional `:threshold` argument that defines the maximum number
of elements in the cache before the LRU semantics apply (default is 32).

source raw docstring

lu-cache-factory^clj

(lu-cache-factory base & {threshold :threshold :or {threshold 32}})

Returns an LU cache with the cache and usage-table initialized to base.

This function takes an optional :threshold argument that defines the maximum number of elements in the cache before the LU semantics apply (default is 32).

Returns an LU cache with the cache and usage-table initialized to `base`.

This function takes an optional `:threshold` argument that defines the maximum number
of elements in the cache before the LU semantics apply (default is 32).

source

soft-cache-factory^clj

(soft-cache-factory base)

Returns a SoftReference cache. Cached values will be referred to with SoftReferences, allowing the values to be garbage collected when there is memory pressure on the JVM.

SoftCache is a mutable cache, since it is always based on a ConcurrentHashMap.

Returns a SoftReference cache.  Cached values will be referred to with
SoftReferences, allowing the values to be garbage collected when there is
memory pressure on the JVM.

SoftCache is a mutable cache, since it is always based on a
ConcurrentHashMap.

source raw docstring

through^clj

(through cache item)

(through value-fn cache item)

(through wrap-fn value-fn cache item)

The basic hit/miss logic for the cache system. Expects a wrap function and value function. The wrap function takes the value function and the item in question and is expected to run the value function with the item whenever a cache miss occurs. The intent is to hide any cache-specific cells from leaking into the cache logic itelf.

The basic hit/miss logic for the cache system.  Expects a wrap function and
value function.  The wrap function takes the value function and the item in question
and is expected to run the value function with the item whenever a cache
miss occurs.  The intent is to hide any cache-specific cells from leaking
into the cache logic itelf.

source raw docstring

through-cache^clj

(through-cache cache item)

(through-cache cache item value-fn)

(through-cache cache item wrap-fn value-fn)

The basic hit/miss logic for the cache system. Like through but always has the cache argument in the first position for easier use with swap! etc.

The basic hit/miss logic for the cache system.  Like through but always has
the cache argument in the first position for easier use with swap! etc.

source raw docstring

ttl-cache-factory^clj

(ttl-cache-factory base & {ttl :ttl :or {ttl 2000}})

Returns a TTL cache with the cache and expiration-table initialized to base -- each with the same time-to-live.

This function also allows an optional :ttl argument that defines the default time in milliseconds that entries are allowed to reside in the cache.

Returns a TTL cache with the cache and expiration-table initialized to `base` --
each with the same time-to-live.

This function also allows an optional `:ttl` argument that defines the default
time in milliseconds that entries are allowed to reside in the cache.

Chat on Slack

× close