Repository

Get the number of seconds until the given DateTime.

Get the "available at" UNIX timestamp.

If the given value is an interval, convert it to a DateTime instance.

Get the current system time as a UNIX timestamp.

Given a start time, format the total run time for human readability.

Register a custom macro.

Boot-only. Macros persist in a static property for the worker lifetime and apply to every subsequent call on the macroable class.

Mix another object into the class.

Boot-only. Delegates to macro() for each method; registered macros persist in a static property for the worker lifetime.

Check if macro is registered.

Flush the existing macros.

Boot or tests only. Clears worker-wide macros; concurrent coroutines may resolve different methods depending on timing.

Dynamically handle calls to the class.

Handle dynamic calls into macros or pass missing methods to the store.

Create a new cache repository instance.

Determine if an item exists in the cache.

Determine if an item doesn't exist in the cache.

Retrieve an item from the cache by key.

When an array is given, return a key-value map. Numeric entries are requested keys, while string-keyed entries use their values as defaults.

Retrieve multiple items from the cache by key.

Items not found in the cache will have a null value.

Retrieve multiple items from the cache by key.

Retrieve an item from the cache and delete it.

Retrieve a string item from the cache.

Retrieve an integer item from the cache.

Retrieve a float item from the cache.

Retrieve a boolean item from the cache.

Retrieve an array item from the cache.

Store an item in the cache.

Store an item in the cache.

Store multiple items in the cache for a given number of seconds.

Store multiple items in the cache.

Store an item in the cache if the key does not exist.

Increment the value of an item in the cache.

Decrement the value of an item in the cache.

Store an item in the cache indefinitely.

Get an item from the cache, or execute the given Closure and store the result.

Get an item from the cache, or execute the given Closure and store the result.

Retrieve an item for remember operations without unwrapping sentinels.

Get an item from the cache, or execute the given Closure and store the result.

Unlike remember(), a null return from $callback is stored (as the internal NullSentinel::VALUE marker) and returned as null on subsequent calls rather than triggering re-execution. Public accessors (get, many, pull, has, etc.) unwrap the sentinel automatically — callers never see it.

Get an item from the cache, or execute the given Closure and store the result forever.

Get an item from the cache, or execute the given Closure and store the result forever.

Alias for rememberForeverNullable().

Get an item from the cache, or execute the given Closure and store the result forever.

Get an item from the cache, or execute the given Closure and store the result forever.

Unlike rememberForever(), a null return from $callback is stored (as the internal NullSentinel::VALUE marker) and returned as null on subsequent calls rather than triggering re-execution. Public accessors unwrap the sentinel automatically.

Retrieve an item from the cache by key, refreshing it in the background if it is stale.

Retrieve an item from the cache by key, refreshing it in the background if it is stale.

Unlike flexible(), a null return from $callback is stored (as the internal NullSentinel::VALUE marker) and returned as null on subsequent calls rather than triggering re-execution. Public accessors unwrap the sentinel automatically.

Inherits flexible()'s support matrix: unsupported on any-mode tagged caches (tags()->flexibleNullable() on a TagMode::Any store throws the same BadMethodCallException that tags()->flexible() does, because flexible() internally reads via manyRaw() (initial batched read) and getAuthoritativeRaw() (acquired-lock refresh read), both of which AnyTaggedCache overrides to throw in any-mode).

Set the expiration of a cached item.

Execute a callback while holding an atomic lock on a cache mutex to prevent overlapping calls.

Funnel a callback for a maximum number of simultaneous executions.

Remove an item from the cache.

Remove an item from the cache.

Delete multiple items from the cache by key.

Remove all items from the cache.

Flush all locks from the cache store.

Begin executing a new tags operation if the store supports it.

Determine if the current store supports tags.

Determine if the current store supports flushing locks.

Get the default cache time.

Set the default cache time in seconds.

Boot-only. Persists on the cached repository for the worker lifetime and applies to every subsequent write that falls back to the default TTL; per-request use races across coroutines.

Get the cache store implementation.

Set the cache store implementation.

Boot-only. Replaces the backing store on the cached repository for the worker lifetime; per-request use races and every concurrent read/write through this repository would hit the wrong store.

Get the event dispatcher instance.

Set the event dispatcher instance.

Boot or tests only. Persists on the cached repository for the worker lifetime; per-request use races across coroutines. Reached by CacheManager::refreshEventDispatcher() from Event::fake() / fakeFor().

Register a callback to be invoked when an unserializable class is encountered.

Boot or tests only. The callback persists for the worker lifetime and affects every subsequent cache read.

Get the cache store name.

Determine if a cached value exists.

Retrieve an item from the cache by key.

Store an item in the cache for the default time.

Remove an item from the cache.

Handle a result for the "many" method.

Store multiple items in the cache indefinitely.

Format the key for a cache item.

Handle a cache value that contains an incomplete class.

Calculate the number of seconds for the given TTL.

Fire an event for this cache instance.

Retrieve an item from the cache by key without unwrapping sentinels.

Retrieve an item without serving it from a non-authoritative read layer.

Retrieve multiple items from the cache by key without unwrapping sentinels.

Flush all static state.

Clone cache repository instance.