Class.php

Go to the documentation of this file.

<?php
#require_once 'Zend/Cache/Core.php';


class Zend_Cache_Frontend_Class extends Zend_Cache_Core
{
    protected $_specificOptions = array(
        'cached_entity'      => null,
        'cache_by_default'   => true,
        'cached_methods'     => array(),
        'non_cached_methods' => array()
    );

    protected $_tags = array();

    protected $_specificLifetime = false;

    protected $_cachedEntity = null;

    protected $_cachedEntityLabel = '';

    protected $_priority = 8;

    public function __construct(array $options = array())
    {
        foreach ($options as $name => $value) {
            $this->setOption($name, $value);
        }
        if ($this->_specificOptions['cached_entity'] === null) {
            Zend_Cache::throwException('cached_entity must be set !');
        }
        $this->setCachedEntity($this->_specificOptions['cached_entity']);
        $this->setOption('automatic_serialization', true);
    }

    public function setSpecificLifetime($specificLifetime = false)
    {
        $this->_specificLifetime = $specificLifetime;
    }

    public function setPriority($priority)
    {
        $this->_priority = $priority;
    }

    public function setOption($name, $value)
    {
        if ($name == 'cached_entity') {
            $this->setCachedEntity($value);
        } else {
            parent::setOption($name, $value);
        }
    }

    public function setCachedEntity($cachedEntity)
    {
        if (!is_string($cachedEntity) && !is_object($cachedEntity)) {
            Zend_Cache::throwException(
                'cached_entity must be an object or a class name'
            );
        }

        $this->_cachedEntity                     = $cachedEntity;
        $this->_specificOptions['cached_entity'] = $cachedEntity;

        if (is_string($this->_cachedEntity)) {
            $this->_cachedEntityLabel = $this->_cachedEntity;
        } else {
            $ro = new ReflectionObject($this->_cachedEntity);
            $this->_cachedEntityLabel = $ro->getName();
        }
    }

    public function setTagsArray($tags = array())
    {
        $this->_tags = $tags;
    }

    public function __call($name, $parameters)
    {
        $callback = array($this->_cachedEntity, $name);

        if (!is_callable($callback, false)) {
            Zend_Cache::throwException('Invalid callback');
        }

        $cacheBool1 = $this->_specificOptions['cache_by_default'];
        $cacheBool2 = in_array($name, $this->_specificOptions['cached_methods']);
        $cacheBool3 = in_array($name, $this->_specificOptions['non_cached_methods']);
        $cache      = (($cacheBool1 || $cacheBool2) && (!$cacheBool3));

        if (!$cache) {
            // We do not have not cache
            return call_user_func_array($callback, $parameters);
        }

        $id = $this->makeId($name, $parameters);
        if (($rs = $this->load($id)) && (array_key_exists(0, $rs))
            && (array_key_exists(1, $rs))
        ) {
            // A cache is available
            $output = $rs[0];
            $return = $rs[1];
        } else {
            // A cache is not available (or not valid for this frontend)
            ob_start();
            ob_implicit_flush(false);

            try {
                $return = call_user_func_array($callback, $parameters);
                $output = ob_get_clean();
                $data   = array($output, $return);

                $this->save(
                    $data, $id, $this->_tags, $this->_specificLifetime,
                    $this->_priority
                );
            } catch (Exception $e) {
                ob_end_clean();
                throw $e;
            }
        }

        echo $output;
        return $return;
    }

    private function _makeId($name, $args)
    {
        return $this->makeId($name, $args);
    }

    public function makeId($name, array $args = array())
    {
        return md5($this->_cachedEntityLabel . '__' . $name . '__' . serialize($args));
    }
}