Question

I want to implement a class, which caches some internal results. These results are the same for all instances of the class, i.e. it might be wise to share this cache among all instances.

However, these results may be different for sub-classes, i.e. the cache shall not be shared with sub-classes. Since the cache is a good idea for all sub-classes as well, the mechanism shall be inherited nevertheless. But each sub-class has to use a different static array.

I can think of various hacks and complicated patterns to attain this goal, but none looks really sane. Does anybody know of an efficient pattern in PHP?

Answer 1

A combination of a private static variable to hold the cached data for all subclasses and protected accessor functions sounds like it would work, and it’s not too complicated:

class Base {
    private static $cache = array();

    protected getCacheItem($key) {
        $type = get_class($this);
        if (!isset(self::$cache[$type])) {
            self::$cache[$type] = array();
        }

        // add checks to taste
        return self::$cache[$type][$key];
    }

    protected function setCacheItem($key, $value) {
        // similar to the above
    }
}

Taking it from here, you can get fancy so that accessing the cache is very convenient at the price of becoming somewhat evil:

class Base {
    private static $cache = array();

    // WARNING! QUESTIONABLE PRACTICE: __get returns by reference
    // Also, overriding __get ONLY might not lead to an intuitive experience
    // As always, documenting non-standard behavior is paramount!
    public function &__get($name) {
        if ($name != 'cache') {
            // error handling
        }

        $type = get_class($this);
        if (!isset(self::$cache[$type])) {
            self::$cache[$type] = array();
        }

        return self::$cache[$type];
    }
}

You would then be able to use this like

$b = new Base;
$b->cache['foo'] = 'bar';

See it in action.