Make WordPress Core


Ignore:
Timestamp:
02/06/2020 05:51:58 AM (7 years ago)
Author:
SergeyBiryukov
Message:

Coding Standards: Move WP_Object_Cache to wp-includes/class-wp-object-cache.php.

This ensures the file containing the WP_Object_Cache class conforms to the coding standards.

For backward compatibility, the new file is included from wp-includes/cache.php.

Fixes #49373. See #49222.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/wp-includes/cache.php

    r47107 r47197  
    88 * @subpackage Cache
    99 */
     10
     11/** WP_Object_Cache class */
     12require_once ABSPATH . WPINC . '/class-wp-object-cache.php';
    1013
    1114/**
     
    271274        $wp_object_cache->reset();
    272275}
    273 
    274 /**
    275  * Core class that implements an object cache.
    276  *
    277  * The WordPress Object Cache is used to save on trips to the database. The
    278  * Object Cache stores all of the cache data to memory and makes the cache
    279  * contents available by using a key, which is used to name and later retrieve
    280  * the cache contents.
    281  *
    282  * The Object Cache can be replaced by other caching mechanisms by placing files
    283  * in the wp-content folder which is looked at in wp-settings. If that file
    284  * exists, then this file will not be included.
    285  *
    286  * @since 2.0.0
    287  */
    288 class WP_Object_Cache {
    289 
    290         /**
    291          * Holds the cached objects.
    292          *
    293          * @since 2.0.0
    294          * @var array
    295          */
    296         private $cache = array();
    297 
    298         /**
    299          * The amount of times the cache data was already stored in the cache.
    300          *
    301          * @since 2.5.0
    302          * @var int
    303          */
    304         public $cache_hits = 0;
    305 
    306         /**
    307          * Amount of times the cache did not have the request in cache.
    308          *
    309          * @since 2.0.0
    310          * @var int
    311          */
    312         public $cache_misses = 0;
    313 
    314         /**
    315          * List of global cache groups.
    316          *
    317          * @since 3.0.0
    318          * @var array
    319          */
    320         protected $global_groups = array();
    321 
    322         /**
    323          * The blog prefix to prepend to keys in non-global groups.
    324          *
    325          * @since 3.5.0
    326          * @var string
    327          */
    328         private $blog_prefix;
    329 
    330         /**
    331          * Holds the value of is_multisite().
    332          *
    333          * @since 3.5.0
    334          * @var bool
    335          */
    336         private $multisite;
    337 
    338         /**
    339          * Sets up object properties; PHP 5 style constructor.
    340          *
    341          * @since 2.0.8
    342          */
    343         public function __construct() {
    344                 $this->multisite   = is_multisite();
    345                 $this->blog_prefix = $this->multisite ? get_current_blog_id() . ':' : '';
    346         }
    347 
    348         /**
    349          * Makes private properties readable for backward compatibility.
    350          *
    351          * @since 4.0.0
    352          *
    353          * @param string $name Property to get.
    354          * @return mixed Property.
    355          */
    356         public function __get( $name ) {
    357                 return $this->$name;
    358         }
    359 
    360         /**
    361          * Makes private properties settable for backward compatibility.
    362          *
    363          * @since 4.0.0
    364          *
    365          * @param string $name  Property to set.
    366          * @param mixed  $value Property value.
    367          * @return mixed Newly-set property.
    368          */
    369         public function __set( $name, $value ) {
    370                 return $this->$name = $value;
    371         }
    372 
    373         /**
    374          * Makes private properties checkable for backward compatibility.
    375          *
    376          * @since 4.0.0
    377          *
    378          * @param string $name Property to check if set.
    379          * @return bool Whether the property is set.
    380          */
    381         public function __isset( $name ) {
    382                 return isset( $this->$name );
    383         }
    384 
    385         /**
    386          * Makes private properties un-settable for backward compatibility.
    387          *
    388          * @since 4.0.0
    389          *
    390          * @param string $name Property to unset.
    391          */
    392         public function __unset( $name ) {
    393                 unset( $this->$name );
    394         }
    395 
    396         /**
    397          * Adds data to the cache if it doesn't already exist.
    398          *
    399          * @since 2.0.0
    400          *
    401          * @uses WP_Object_Cache::_exists() Checks to see if the cache already has data.
    402          * @uses WP_Object_Cache::set()     Sets the data after the checking the cache
    403          *                                  contents existence.
    404          *
    405          * @param int|string $key    What to call the contents in the cache.
    406          * @param mixed      $data   The contents to store in the cache.
    407          * @param string     $group  Optional. Where to group the cache contents. Default 'default'.
    408          * @param int        $expire Optional. When to expire the cache contents. Default 0 (no expiration).
    409          * @return bool True on success, false if cache key and group already exist.
    410          */
    411         public function add( $key, $data, $group = 'default', $expire = 0 ) {
    412                 if ( wp_suspend_cache_addition() ) {
    413                         return false;
    414                 }
    415 
    416                 if ( empty( $group ) ) {
    417                         $group = 'default';
    418                 }
    419 
    420                 $id = $key;
    421                 if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) {
    422                         $id = $this->blog_prefix . $key;
    423                 }
    424 
    425                 if ( $this->_exists( $id, $group ) ) {
    426                         return false;
    427                 }
    428 
    429                 return $this->set( $key, $data, $group, (int) $expire );
    430         }
    431 
    432         /**
    433          * Sets the list of global cache groups.
    434          *
    435          * @since 3.0.0
    436          *
    437          * @param array $groups List of groups that are global.
    438          */
    439         public function add_global_groups( $groups ) {
    440                 $groups = (array) $groups;
    441 
    442                 $groups              = array_fill_keys( $groups, true );
    443                 $this->global_groups = array_merge( $this->global_groups, $groups );
    444         }
    445 
    446         /**
    447          * Decrements numeric cache item's value.
    448          *
    449          * @since 3.3.0
    450          *
    451          * @param int|string $key    The cache key to decrement.
    452          * @param int        $offset Optional. The amount by which to decrement the item's value. Default 1.
    453          * @param string     $group  Optional. The group the key is in. Default 'default'.
    454          * @return int|false The item's new value on success, false on failure.
    455          */
    456         public function decr( $key, $offset = 1, $group = 'default' ) {
    457                 if ( empty( $group ) ) {
    458                         $group = 'default';
    459                 }
    460 
    461                 if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) {
    462                         $key = $this->blog_prefix . $key;
    463                 }
    464 
    465                 if ( ! $this->_exists( $key, $group ) ) {
    466                         return false;
    467                 }
    468 
    469                 if ( ! is_numeric( $this->cache[ $group ][ $key ] ) ) {
    470                         $this->cache[ $group ][ $key ] = 0;
    471                 }
    472 
    473                 $offset = (int) $offset;
    474 
    475                 $this->cache[ $group ][ $key ] -= $offset;
    476 
    477                 if ( $this->cache[ $group ][ $key ] < 0 ) {
    478                         $this->cache[ $group ][ $key ] = 0;
    479                 }
    480 
    481                 return $this->cache[ $group ][ $key ];
    482         }
    483 
    484         /**
    485          * Removes the contents of the cache key in the group.
    486          *
    487          * If the cache key does not exist in the group, then nothing will happen.
    488          *
    489          * @since 2.0.0
    490          *
    491          * @param int|string $key        What the contents in the cache are called.
    492          * @param string     $group      Optional. Where the cache contents are grouped. Default 'default'.
    493          * @param bool       $deprecated Optional. Unused. Default false.
    494          * @return bool False if the contents weren't deleted and true on success.
    495          */
    496         public function delete( $key, $group = 'default', $deprecated = false ) {
    497                 if ( empty( $group ) ) {
    498                         $group = 'default';
    499                 }
    500 
    501                 if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) {
    502                         $key = $this->blog_prefix . $key;
    503                 }
    504 
    505                 if ( ! $this->_exists( $key, $group ) ) {
    506                         return false;
    507                 }
    508 
    509                 unset( $this->cache[ $group ][ $key ] );
    510                 return true;
    511         }
    512 
    513         /**
    514          * Clears the object cache of all data.
    515          *
    516          * @since 2.0.0
    517          *
    518          * @return true Always returns true.
    519          */
    520         public function flush() {
    521                 $this->cache = array();
    522 
    523                 return true;
    524         }
    525 
    526         /**
    527          * Retrieves the cache contents, if it exists.
    528          *
    529          * The contents will be first attempted to be retrieved by searching by the
    530          * key in the cache group. If the cache is hit (success) then the contents
    531          * are returned.
    532          *
    533          * On failure, the number of cache misses will be incremented.
    534          *
    535          * @since 2.0.0
    536          *
    537          * @param int|string $key    What the contents in the cache are called.
    538          * @param string     $group  Optional. Where the cache contents are grouped. Default 'default'.
    539          * @param bool       $force  Optional. Unused. Whether to force a refetch rather than relying on the local
    540          *                           cache. Default false.
    541          * @param bool       $found  Optional. Whether the key was found in the cache (passed by reference).
    542          *                           Disambiguates a return of false, a storable value. Default null.
    543          * @return mixed|false The cache contents on success, false on failure to retrieve contents.
    544          */
    545         public function get( $key, $group = 'default', $force = false, &$found = null ) {
    546                 if ( empty( $group ) ) {
    547                         $group = 'default';
    548                 }
    549 
    550                 if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) {
    551                         $key = $this->blog_prefix . $key;
    552                 }
    553 
    554                 if ( $this->_exists( $key, $group ) ) {
    555                         $found             = true;
    556                         $this->cache_hits += 1;
    557                         if ( is_object( $this->cache[ $group ][ $key ] ) ) {
    558                                 return clone $this->cache[ $group ][ $key ];
    559                         } else {
    560                                 return $this->cache[ $group ][ $key ];
    561                         }
    562                 }
    563 
    564                 $found               = false;
    565                 $this->cache_misses += 1;
    566                 return false;
    567         }
    568 
    569         /**
    570          * Increments numeric cache item's value.
    571          *
    572          * @since 3.3.0
    573          *
    574          * @param int|string $key    The cache key to increment
    575          * @param int        $offset Optional. The amount by which to increment the item's value. Default 1.
    576          * @param string     $group  Optional. The group the key is in. Default 'default'.
    577          * @return int|false The item's new value on success, false on failure.
    578          */
    579         public function incr( $key, $offset = 1, $group = 'default' ) {
    580                 if ( empty( $group ) ) {
    581                         $group = 'default';
    582                 }
    583 
    584                 if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) {
    585                         $key = $this->blog_prefix . $key;
    586                 }
    587 
    588                 if ( ! $this->_exists( $key, $group ) ) {
    589                         return false;
    590                 }
    591 
    592                 if ( ! is_numeric( $this->cache[ $group ][ $key ] ) ) {
    593                         $this->cache[ $group ][ $key ] = 0;
    594                 }
    595 
    596                 $offset = (int) $offset;
    597 
    598                 $this->cache[ $group ][ $key ] += $offset;
    599 
    600                 if ( $this->cache[ $group ][ $key ] < 0 ) {
    601                         $this->cache[ $group ][ $key ] = 0;
    602                 }
    603 
    604                 return $this->cache[ $group ][ $key ];
    605         }
    606 
    607         /**
    608          * Replaces the contents in the cache, if contents already exist.
    609          *
    610          * @since 2.0.0
    611          *
    612          * @see WP_Object_Cache::set()
    613          *
    614          * @param int|string $key    What to call the contents in the cache.
    615          * @param mixed      $data   The contents to store in the cache.
    616          * @param string     $group  Optional. Where to group the cache contents. Default 'default'.
    617          * @param int        $expire Optional. When to expire the cache contents. Default 0 (no expiration).
    618          * @return bool False if not exists, true if contents were replaced.
    619          */
    620         public function replace( $key, $data, $group = 'default', $expire = 0 ) {
    621                 if ( empty( $group ) ) {
    622                         $group = 'default';
    623                 }
    624 
    625                 $id = $key;
    626                 if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) {
    627                         $id = $this->blog_prefix . $key;
    628                 }
    629 
    630                 if ( ! $this->_exists( $id, $group ) ) {
    631                         return false;
    632                 }
    633 
    634                 return $this->set( $key, $data, $group, (int) $expire );
    635         }
    636 
    637         /**
    638          * Resets cache keys.
    639          *
    640          * @since 3.0.0
    641          *
    642          * @deprecated 3.5.0 Use switch_to_blog()
    643          * @see switch_to_blog()
    644          */
    645         public function reset() {
    646                 _deprecated_function( __FUNCTION__, '3.5.0', 'switch_to_blog()' );
    647 
    648                 // Clear out non-global caches since the blog ID has changed.
    649                 foreach ( array_keys( $this->cache ) as $group ) {
    650                         if ( ! isset( $this->global_groups[ $group ] ) ) {
    651                                 unset( $this->cache[ $group ] );
    652                         }
    653                 }
    654         }
    655 
    656         /**
    657          * Sets the data contents into the cache.
    658          *
    659          * The cache contents are grouped by the $group parameter followed by the
    660          * $key. This allows for duplicate ids in unique groups. Therefore, naming of
    661          * the group should be used with care and should follow normal function
    662          * naming guidelines outside of core WordPress usage.
    663          *
    664          * The $expire parameter is not used, because the cache will automatically
    665          * expire for each time a page is accessed and PHP finishes. The method is
    666          * more for cache plugins which use files.
    667          *
    668          * @since 2.0.0
    669          *
    670          * @param int|string $key    What to call the contents in the cache.
    671          * @param mixed      $data   The contents to store in the cache.
    672          * @param string     $group  Optional. Where to group the cache contents. Default 'default'.
    673          * @param int        $expire Not Used.
    674          * @return true Always returns true.
    675          */
    676         public function set( $key, $data, $group = 'default', $expire = 0 ) {
    677                 if ( empty( $group ) ) {
    678                         $group = 'default';
    679                 }
    680 
    681                 if ( $this->multisite && ! isset( $this->global_groups[ $group ] ) ) {
    682                         $key = $this->blog_prefix . $key;
    683                 }
    684 
    685                 if ( is_object( $data ) ) {
    686                         $data = clone $data;
    687                 }
    688 
    689                 $this->cache[ $group ][ $key ] = $data;
    690                 return true;
    691         }
    692 
    693         /**
    694          * Echoes the stats of the caching.
    695          *
    696          * Gives the cache hits, and cache misses. Also prints every cached group,
    697          * key and the data.
    698          *
    699          * @since 2.0.0
    700          */
    701         public function stats() {
    702                 echo '<p>';
    703                 echo "<strong>Cache Hits:</strong> {$this->cache_hits}<br />";
    704                 echo "<strong>Cache Misses:</strong> {$this->cache_misses}<br />";
    705                 echo '</p>';
    706                 echo '<ul>';
    707                 foreach ( $this->cache as $group => $cache ) {
    708                         echo "<li><strong>Group:</strong> $group - ( " . number_format( strlen( serialize( $cache ) ) / KB_IN_BYTES, 2 ) . 'k )</li>';
    709                 }
    710                 echo '</ul>';
    711         }
    712 
    713         /**
    714          * Switches the internal blog ID.
    715          *
    716          * This changes the blog ID used to create keys in blog specific groups.
    717          *
    718          * @since 3.5.0
    719          *
    720          * @param int $blog_id Blog ID.
    721          */
    722         public function switch_to_blog( $blog_id ) {
    723                 $blog_id           = (int) $blog_id;
    724                 $this->blog_prefix = $this->multisite ? $blog_id . ':' : '';
    725         }
    726 
    727         /**
    728          * Serves as a utility function to determine whether a key exists in the cache.
    729          *
    730          * @since 3.4.0
    731          *
    732          * @param int|string $key   Cache key to check for existence.
    733          * @param string     $group Cache group for the key existence check.
    734          * @return bool Whether the key exists in the cache for the given group.
    735          */
    736         protected function _exists( $key, $group ) {
    737                 return isset( $this->cache[ $group ] ) && ( isset( $this->cache[ $group ][ $key ] ) || array_key_exists( $key, $this->cache[ $group ] ) );
    738         }
    739 }
Note: See TracChangeset for help on using the changeset viewer.