magic methods - Can I use them to catch the inaccessible static property?

Question

Can I use magic method to catch the inaccessible static property for Access to undeclared static property?

for instance,

class greeting 
{
    static public function init()
    {
        static::$message = 'Hello World!';
    }

    /*
     *  Set the inaccessible property magically.
     */
    public function __set($name, $value)
    {
        var_dump($name); // set the property here?
    }

    /*
     *  Get the inaccessible $class magically.
     */
    public function __get($name)
    {
        var_dump($name); // set the property here?
    }
}

greeting::init();
var_dump(greeting::$message);

I get,

Fatal error: Access to undeclared static property: greeting::$messsage in C:...

Answer 1

Don't think so. There's no magic method like __getStatic or __setStatic. As far as your question deals with the registry pattern, you can do this:

Use the standard registry pattern:

class Reg {

    private $register = array();

    private static $instance = null;

    public static function getInstance()
    {
        if ( self::$instance === null)
        {
            self::$instance = new Registry;
        }

        return self::$instance;
    }

    public function __set($key, $val)
    {
        $this->register[$key] = $val;
    }

    public function __get($key)
    {
        if (isset($this->register[$key]))
        {
            return $this->register[$key];
        }
        else
        {
            return null;
        }
    }
}

call:

$reg = Reg::getInstance();
$reg->foo = 'bar';
echo $reg->foo;

OR use an abstract registry class with (non-magic) getters and setters:

abstract class Reg {

    private static $register = array();

    public static function set($key, $val)
    {
        self::$register[$key] = $val;
    }

    public static function get($key)
    {
        if (isset(self::$register[$key]))
        {
            return self::$register[$key];
        }
        else
        {
            return null;
        }
    }
}

call:

Reg::set('foo','bar');
echo Reg::get('foo');

Advantage: no need to instantiate a Registry class

OR use an abstract registry class with magic callStatic method:

abstract class Reg {

    private static $register = array();

    public static function __callStatic($key, $val)
    {
        if(count($val))
        {
            self::$register[$key] = $val[0]; // $val is passed as array, so take first item
        }
        else
        {
            if (isset(self::$register[$key]))
            {
                return self::$register[$key];
            }
            else
            {
                return null;
            }           
        }
    }
}

call:

Reg::foo('bar');
echo Reg::foo();

Advantage: Less characters needed to set and get variables.

Disadvantage: Bad performance.

In a little test with 1.000.000 loops I got the following:

Method 1) 2,319s

Method 2) 1,416s

Method 3) 3,708s

So an abstract registry with non-magic (but at least static) getters and setters seems to be the best solution.