xoopscache.php

Go to the documentation of this file.

<?php
defined('XOOPS_ROOT_PATH') or die('Restricted access');

class XoopsCache
{
    var $engine = null;
    // static $engine = null;


    var $configs = array();

    var $name = null;

    function __construct()
    {
    }

    static function &getInstance()
    {
        static $instance;
        if (!isset($instance)) {
            $class = __CLASS__;
            $instance = new $class();
        }
        return $instance;
    }

    function loadEngine($name)
    {
        if (!class_exists('XoopsCache' . ucfirst($name))) {
            if (file_exists($file = dirname(__FILE__) . '/' . strtolower($name) . '.php')) {
                include $file;
            } else {
                trigger_error('File :' . $file . ' not found in file : ' . __FILE__ . ' at line: ' . __LINE__, E_USER_WARNING);
                return false;
            }
        }
        return true;
    }

    function config($name = 'default', $settings = array())
    {
        $_this =& XoopsCache::getInstance();
        if (is_array($name)) {
            extract($name);
        }

        if (isset($_this->configs[$name])) {
            $settings = array_merge($_this->configs[$name], $settings);
        } else if (!empty($settings)) {
            $_this->configs[$name] = $settings;
        } else if ($_this->configs !== null && isset($_this->configs[$_this->name])) {
            $name = $_this->name;
            $settings = $_this->configs[$_this->name];
        } else {
            $name = 'default';
            if (!empty($_this->configs['default'])) {
                $settings = $_this->configs['default'];
            } else {
                $settings = array(
                    'engine' => 'file');
            }
        }
        $engine = 'file';
        if (!empty($settings['engine'])) {
            $engine = $settings['engine'];
        }

        if ($name !== $_this->name) {
            if ($_this->engine($engine, $settings) === false) {
                trigger_error("Cache Engine {$engine} is not set", E_USER_WARNING);
                return false;
            }
            $_this->name = $name;
            $_this->configs[$name] = $_this->settings($engine);
        }

        $settings = $_this->configs[$name];
        return compact('engine', 'settings');
    }

    function engine($name = 'file', $settings = array())
    {
        if (!$name) {
            return false;
        }

        $cacheClass = 'XoopsCache' . ucfirst($name);
        $_this =& XoopsCache::getInstance();
        if (!isset($_this->engine[$name])) {
            if ($_this->loadEngine($name) === false) {
                trigger_error("Cache Engine {$name} is not loaded", E_USER_WARNING);
                return false;
            }
            $_this->engine[$name] = new $cacheClass();
        }

        if ($_this->engine[$name]->init($settings)) {
            if (time() % $_this->engine[$name]->settings['probability'] == 0) {
                $_this->engine[$name]->gc();
            }
            return true;
        }
        $_this->engine[$name] = null;
        trigger_error("Cache Engine {$name} is not initialized", E_USER_WARNING);
        return false;
    }

    function gc()
    {
        $_this =& XoopsCache::getInstance();
        $config = $_this->config();
        extract($config);
        $_this->engine[$engine]->gc();
    }

    function write($key, $value, $duration = null)
    {
        $key = substr(md5(XOOPS_URL), 0, 8) . '_' . $key;
        $_this =& XoopsCache::getInstance();
        $config = null;
        if (is_array($duration)) {
            extract($duration);
        } else if (isset($_this->configs[$duration])) {
            $config = $duration;
            $duration = null;
        }
        $config = $_this->config($config);

        if (!is_array($config)) {
            return null;
        }
        extract($config);

        if (!$_this->isInitialized($engine)) {
            trigger_error('Cache write not initialized: ' . $engine);
            return false;
        }

        if (!$key = $_this->key($key)) {
            return false;
        }

        if (is_resource($value)) {
            return false;
        }

        if (!$duration) {
            $duration = $settings['duration'];
        }
        $duration = is_numeric($duration) ? intval($duration) : strtotime($duration) - time();

        if ($duration < 1) {
            return false;
        }
        $_this->engine[$engine]->init($settings);
        $success = $_this->engine[$engine]->write($key, $value, $duration);
        return $success;
    }

    static function read($key, $config = null)
    {
        $key = substr(md5(XOOPS_URL), 0, 8) . '_' . $key;
        $_this =& XoopsCache::getInstance();
        $config = $_this->config($config);

        if (!is_array($config)) {
            return null;
        }

        extract($config);

        if (!$_this->isInitialized($engine)) {
            return false;
        }
        if (!$key = $_this->key($key)) {
            return false;
        }
        $_this->engine[$engine]->init($settings);
        $success = $_this->engine[$engine]->read($key);
        return $success;
    }

    function delete($key, $config = null)
    {
        $key = substr(md5(XOOPS_URL), 0, 8) . '_' . $key;
        $_this =& XoopsCache::getInstance();

        $config = $_this->config($config);
        extract($config);

        if (!$_this->isInitialized($engine)) {
            return false;
        }

        if (!$key = $_this->key($key)) {
            return false;
        }

        $_this->engine[$engine]->init($settings);
        $success = $_this->engine[$engine]->delete($key);
        return $success;
    }

    function clear($check = false, $config = null)
    {
        $_this =& XoopsCache::getInstance();
        $config = $_this->config($config);
        extract($config);

        if (!$_this->isInitialized($engine)) {
            return false;
        }
        $success = $_this->engine[$engine]->clear($check);
        $_this->engine[$engine]->init($settings);
        return $success;
    }

    function isInitialized($engine = null)
    {
        $_this =& XoopsCache::getInstance();
        if (!$engine && isset($_this->configs[$_this->name]['engine'])) {
            $engine = $_this->configs[$_this->name]['engine'];
        }

        return isset($_this->engine[$engine]);
    }

    function settings($engine = null)
    {
        $_this =& XoopsCache::getInstance();
        if (!$engine && isset($_this->configs[$_this->name]['engine'])) {
            $engine = $_this->configs[$_this->name]['engine'];
        }
        if (isset($_this->engine[$engine]) && ! is_null($_this->engine[$engine])) {
            return $_this->engine[$engine]->settings();
        }
        return array();
    }

    function key($key)
    {
        if (empty($key)) {
            return false;
        }
        $key = str_replace(array('/', '.'), '_', strval($key));
        return $key;
    }
}

class XoopsCacheEngine
{
    var $settings;

    function init($settings = array())
    {
        $this->settings = array_merge(array(
            'duration' => 31556926 ,
            'probability' => 100), $settings);
        return true;
    }

    function gc()
    {
    }

    function write($key, $value = null, $duration = null)
    {
        trigger_error(sprintf(__('Method write() not implemented in %s', true), get_class($this)), E_USER_ERROR);
    }

    function read($key)
    {
        trigger_error(sprintf(__('Method read() not implemented in %s', true), get_class($this)), E_USER_ERROR);
    }

    function delete($key)
    {
    }

    function clear($check)
    {
    }

    function settings()
    {
        return $this->settings;
    }
}

?>