class ThemeRegistry in Drupal 7

Builds the run-time theme registry.

Extends DrupalCacheArray to allow the theme registry to be accessed as a complete registry, while internally caching only the parts of the registry that are actually in use on the site. On cache misses the complete theme registry is loaded and used to update the run-time cache.

Hierarchy

• class \DrupalCacheArray implements \ArrayAccess
  • class \ThemeRegistry

1 string reference to 'ThemeRegistry'

ThemeRegistryTestCase::getInfo in modules/simpletest/tests/theme.test

File

includes/theme.inc, line 365

The theme system, which controls the output of Drupal.

class ThemeRegistry extends DrupalCacheArray {

  /**
   * Whether the partial registry can be persisted to the cache.
   *
   * This is only allowed if all modules and the request method is GET. theme()
   * should be very rarely called on POST requests and this avoids polluting
   * the runtime cache.
   */
  protected $persistable;

  /**
   * The complete theme registry array.
   */
  protected $completeRegistry;
  function __construct($cid, $bin) {
    $this->cid = $cid;
    $this->bin = $bin;
    $this->persistable = module_load_all(NULL) && $_SERVER['REQUEST_METHOD'] == 'GET';
    $data = array();
    if ($this->persistable && ($cached = cache_get($this->cid, $this->bin))) {
      $data = $cached->data;
    }
    else {

      // If there is no runtime cache stored, fetch the full theme registry,
      // but then initialize each value to NULL. This allows offsetExists()
      // to function correctly on non-registered theme hooks without triggering
      // a call to resolveCacheMiss().
      $data = $this
        ->initializeRegistry();
      if ($this->persistable) {
        $this
          ->set($data);
      }
    }
    $this->storage = $data;
  }

  /**
   * Initializes the full theme registry.
   *
   * @return
   *   An array with the keys of the full theme registry, but the values
   *   initialized to NULL.
   */
  function initializeRegistry() {
    $this->completeRegistry = theme_get_registry();
    return array_fill_keys(array_keys($this->completeRegistry), NULL);
  }
  public function offsetExists($offset) {

    // Since the theme registry allows for theme hooks to be requested that
    // are not registered, just check the existence of the key in the registry.
    // Use array_key_exists() here since a NULL value indicates that the theme
    // hook exists but has not yet been requested.
    return isset($this->storage[$offset]) || array_key_exists($offset, $this->storage);
  }
  public function offsetGet($offset) {

    // If the offset is set but empty, it is a registered theme hook that has
    // not yet been requested. Offsets that do not exist at all were not
    // registered in hook_theme().
    if (isset($this->storage[$offset])) {
      return $this->storage[$offset];
    }
    elseif (array_key_exists($offset, $this->storage)) {
      return $this
        ->resolveCacheMiss($offset);
    }
  }
  public function resolveCacheMiss($offset) {
    if (!isset($this->completeRegistry)) {
      $this->completeRegistry = theme_get_registry();
    }
    $this->storage[$offset] = $this->completeRegistry[$offset];
    if ($this->persistable) {
      $this
        ->persist($offset);
    }
    return $this->storage[$offset];
  }
  public function set($data, $lock = TRUE) {
    $lock_name = $this->cid . ':' . $this->bin;
    if (!$lock || lock_acquire($lock_name)) {
      if ($cached = cache_get($this->cid, $this->bin)) {

        // Use array merge instead of union so that filled in values in $data
        // overwrite empty values in the current cache.
        $data = array_merge($cached->data, $data);
      }
      else {
        $registry = $this
          ->initializeRegistry();
        $data = array_merge($registry, $data);
      }
      cache_set($this->cid, $data, $this->bin);
      if ($lock) {
        lock_release($lock_name);
      }
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
DrupalCacheArray::$bin	protected	property	A bin to pass to cache_set() and cache_get().
DrupalCacheArray::$cid	protected	property	A cid to pass to cache_set() and cache_get().
DrupalCacheArray::$keysToPersist	protected	property	An array of keys to add to the cache at the end of the request.
DrupalCacheArray::$storage	protected	property	Storage for the data itself.
DrupalCacheArray::offsetSet	public	function	Implements ArrayAccess::offsetSet().
DrupalCacheArray::offsetUnset	public	function	Implements ArrayAccess::offsetUnset().
DrupalCacheArray::persist	protected	function	Flags an offset value to be written to the persistent cache.
DrupalCacheArray::__destruct	public	function	Destructs the DrupalCacheArray object.
ThemeRegistry::$completeRegistry	protected	property	The complete theme registry array.
ThemeRegistry::$persistable	protected	property	Whether the partial registry can be persisted to the cache.
ThemeRegistry::initializeRegistry		function	Initializes the full theme registry.
ThemeRegistry::offsetExists	public	function	Implements ArrayAccess::offsetExists(). Overrides DrupalCacheArray::offsetExists
ThemeRegistry::offsetGet	public	function	Implements ArrayAccess::offsetGet(). Overrides DrupalCacheArray::offsetGet
ThemeRegistry::resolveCacheMiss	public	function	Resolves a cache miss. Overrides DrupalCacheArray::resolveCacheMiss
ThemeRegistry::set	public	function	Writes a value to the persistent cache immediately. Overrides DrupalCacheArray::set
ThemeRegistry::__construct		function	Constructs a DrupalCacheArray object. Overrides DrupalCacheArray::__construct