WordPress.org

Make WordPress Core


Ignore:
Timestamp:
02/06/2020 05:51:58 AM (14 months 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.