vBulletin v6.0.4

vB_Cache_Null extends vB_Cache
in package

Null Cache.

Handler that just does nothing. Mostly needed for installer/upgrader

Tags
see
vB_Cache

Table of Contents

Constants

CACHE_FAST  = 1
CACHE_LARGE  = 2
CACHE_LOG_CLEAR  = 6
CACHE_LOG_HASVALUE  = 4
CACHE_LOG_NOVALUE  = 5
CACHE_LOG_READFAIL  = 3
CACHE_LOG_READSUCCESS  = 2
CACHE_LOG_WRITE  = 1
CACHE_STD  = 0

Methods

__construct()  : mixed
__serialize()  : array<string|int, mixed>
__sleep()  : array<string|int, mixed>
__unserialize()  : void
__wakeup()  : void
allCacheEvent()  : mixed
attachObserver()  : mixed
clean()  : mixed
Cleans cache.
cleanNow()  : mixed
Tells the cache to trigger all events.
event()  : mixed
Expires cache objects based on a triggered event.
expire()  : mixed
Expires a cache object.
getContextKey()  : vB_Context
Get a context key
getDefaults()  : mixed
Get the cache defaults.
instance()  : vB_Cache
Returns an instance of the global cache.
isLoaded()  : bool
has a value been loaded for this key?
lock()  : bool
Locks a cache entry.
purge()  : mixed
Purges a cache object.
read()  : array<string|int, mixed>
Reads an array of cache objects from storage.
readSingle()  : mixed
Reads a cache object and returns the data.
removeObserver()  : mixed
resetAllCache()  : mixed
resetCache()  : mixed
restoreCacheInfo()  : mixed
If we used saveCacheInfo to save data, this will get it back.
saveCacheInfo()  : mixed
Based on the assumption that if we go back to a page we're likely to request a lot of the information we requested last time we were on that page, let's store the cached information.
shutdown()  : mixed
unlock()  : mixed
Unlocks a cache entry.
updateTime()  : mixed
This updates the time. It is useful only for testing. Otherwise it does nothing
write()  : string
Writes data as a cache object.

Constants

CACHE_FAST

public mixed CACHE_FAST = 1

CACHE_LARGE

public mixed CACHE_LARGE = 2

CACHE_LOG_CLEAR

public mixed CACHE_LOG_CLEAR = 6

CACHE_LOG_HASVALUE

public mixed CACHE_LOG_HASVALUE = 4

CACHE_LOG_NOVALUE

public mixed CACHE_LOG_NOVALUE = 5

CACHE_LOG_READFAIL

public mixed CACHE_LOG_READFAIL = 3

CACHE_LOG_READSUCCESS

public mixed CACHE_LOG_READSUCCESS = 2

CACHE_LOG_WRITE

public mixed CACHE_LOG_WRITE = 1

CACHE_STD

public mixed CACHE_STD = 0

Methods

__construct()

public __construct(mixed $cachetype) : mixed
Parameters
$cachetype : mixed

__serialize()

public __serialize() : array<string|int, mixed>
Return values
array<string|int, mixed>

__sleep()

public __sleep() : array<string|int, mixed>
Return values
array<string|int, mixed>

__unserialize()

public __unserialize(array<string|int, mixed> $serialized) : void
Parameters
$serialized : array<string|int, mixed>

allCacheEvent()

public static allCacheEvent(mixed $events) : mixed
Parameters
$events : mixed

attachObserver()

public attachObserver(vB_Cache_Observer $observer) : mixed
Parameters
$observer : vB_Cache_Observer

clean()

Cleans cache.

public clean([mixed $only_expired = true ]) : mixed

$created_before should be a unix timestamp.

Parameters
$only_expired : mixed = true
  • Only clean expired entries

cleanNow()

Tells the cache to trigger all events.

public cleanNow() : mixed

event()

Expires cache objects based on a triggered event.

public event(mixed $events) : mixed
Parameters
$events : mixed

expire()

Expires a cache object.

public expire(mixed $cache_id) : mixed

This is preferred to purging a cache entry as it ensures that that the cache data can still be served while new cache data is being rebuilt.

Parameters
$cache_id : mixed

getContextKey()

Get a context key

public getContextKey(string $prefix, array<string|int, mixed> $values) : vB_Context

This is intended to generate a cache key from complex information, particularly arrays which affect the generation of the cached data. The end result will is not guarenteed to be particular readable (and most likely isn't) but it should be unique to that combination of params.

Parameters
$prefix : string

-- Human readable string to prefix the cachekey. intended to help debugging by allowing inspection to understand where that key came from.

$values : array<string|int, mixed>

-- array/value pairs to encode into the key. Order doesn't matter since they will be sorted on key generation.

Return values
vB_Context

getDefaults()

Get the cache defaults.

public static getDefaults() : mixed

instance()

Returns an instance of the global cache.

public static instance([mixed $type = self::CACHE_STD ]) : vB_Cache

The cache type used is defined in options.

Parameters
$type : mixed = self::CACHE_STD
Return values
vB_Cache —
  • Reference to instance of the cache handler

isLoaded()

has a value been loaded for this key?

public isLoaded(mixed $key) : bool
Parameters
$key : mixed
Return values
bool

lock()

Locks a cache entry.

public lock(mixed $key) : bool

This is done to prevent a cache slam where concurrent connections attempt to rebuild an expired cache entry. While a cache entry is locked, it should be considered valid and served to all connections except the one that has the lock. After the cache entry has been rebuilt it will be unlocked, allowing all new connections to consume the fresh entry.

Parameters
$key : mixed
Return values
bool —
  • TRUE iff the lock was obtained

purge()

Purges a cache object.

public purge(mixed $cache_id) : mixed
Parameters
$cache_id : mixed

read()

Reads an array of cache objects from storage.

public read(mixed $keys[, mixed $writeLock = false ][, mixed $save_meta = false ]) : array<string|int, mixed>
Parameters
$keys : mixed
  • Ids of the cache entry to read
$writeLock : mixed = false
$save_meta : mixed = false
Return values
array<string|int, mixed> —

of array includes key, data, expires

readSingle()

Reads a cache object and returns the data.

public readSingle(mixed $key[, bool &$write_lock = false ][, mixed $save_meta = false ]) : mixed

Integrity checking should be performed by the client code, ensuring that the returned data is in the expected form.

$key should be a string key with all of the identifying information for the required cache objects. This must match the $key used to write the cache object.

The implicit lock can be set to true to indicate that the client code will rebuild the cache on an expired read. This allows cache handlers to lock the cache for the current connection. Normally, if a cache entry is locked then subsequent reads should return the expired cache data until it is unlocked. This cannot be done for cache entries that don't yet exist, but can be used on existing entries to prevent cache slams - where multiple connections decide to rebuild the cache under a race condition.

Cache handlers should ensure to implement an expiration on cache locks.

Parameters
$key : mixed
  • Identifying key. String or array of strings
$write_lock : bool = false
  • Whether a failed read implies a lock for writing
$save_meta : mixed = false
Tags
see
cache::Write()
Return values
mixed —
  • The cached data (string or array of strings) or boolean false

removeObserver()

public removeObserver(vB_Cache_Observer $observer) : mixed
Parameters
$observer : vB_Cache_Observer

resetAllCache()

public static resetAllCache([mixed $expiredOnly = false ]) : mixed
Parameters
$expiredOnly : mixed = false

resetCache()

public static resetCache([mixed $expiredOnly = false ]) : mixed
Parameters
$expiredOnly : mixed = false

restoreCacheInfo()

If we used saveCacheInfo to save data, this will get it back.

public restoreCacheInfo(mixed $cacheid) : mixed
Parameters
$cacheid : mixed

saveCacheInfo()

Based on the assumption that if we go back to a page we're likely to request a lot of the information we requested last time we were on that page, let's store the cached information.

public saveCacheInfo(mixed $cacheid) : mixed
Parameters
$cacheid : mixed

shutdown()

public shutdown() : mixed

unlock()

Unlocks a cache entry.

public unlock(mixed $key) : mixed

Most implementations may unlock the cache during write, making this redundant.

Parameters
$key : mixed

updateTime()

This updates the time. It is useful only for testing. Otherwise it does nothing

public updateTime([mixed $time = false ]) : mixed 
@param	integer		timestamp- optional
Parameters
$time : mixed = false

write()

Writes data as a cache object.

public write(mixed $key, mixed $data[, mixed $lifetime_mins = false ][, mixed $events = false ]) : string

A string key is required to uniquely identify a cache object. Client code should add all information that would affect the individualisation of the cache object to the key.

If lifetime_mins is supplied the cache object will be purged the next time it is read after the TTL has passed.

If a cache object should be purged on triggered events then events should be supplied as an array of string id's of the form 'scope.event', for example 'widget55.updated' may be used to purge a cache of a defined widget with the id 55 when it is reconfigured.

Parameters
$key : mixed
  • Identifying key
$data : mixed
  • Data to cache
$lifetime_mins : mixed = false
$events : mixed = false
Return values
string —

| bool - Cache id or false


        

        
    




    

    

                                

                

                                
    

        On this page

        
    


                

                            

            

    

        

            
Search results