late static binding php6

18 years ago by Mike Lively — view source — reply

unread

Stanislav Malyshev wrote:

in that situation A::find(); would not be able to know it was being
called by B::find() because parent:: is considered an explicit class
name reference.
It will be, just not by means of parent::.
I am missing something....then by what means?

By means of using get_called_class() and then using this information
to call needed method of needed class.
There is still a disconnect somewhere.
<?php

class A
{
static public function test()
{
echo get_called_class();
}
}

class B extends A
{
static public function test()
{
parent::test();
}
}

B::test();

This will echo 'A'. So like I said you have no way here of telling that
B:: was used.

Now if you are talking about something like:

<?php

class A
{
static public function test($called_class)
{
echo $called_class;
}
}

class B
{
static public function test()
{
parent::test(get_class());
}
}

Then there are two problems (sort of). First problem being, then why
bother with lsb, you can do this already (which more so a 'wth' as
opposed to a problem.) The second and much more prevelent problem is
that iirc you cannot do this kind of loose inheritance with statics in
php 6 without getting at least a strict error thrown (Please correct me
if I am wrong, I don't have the latest php6 code at the moment.)

18 years ago by Stanislav Malyshev — view source — reply

unread

   parent::test();

What do you want parent::test() to mean?

This will echo 'A'. So like I said you have no way here of telling that
B:: was used.

Because it wasn't. parent::test() means A::test(). 'parent::' means
'parent class of the class where this statement is' in PHP. For B, it's A.

Then there are two problems (sort of). First problem being, then why
bother with lsb, you can do this already (which more so a 'wth' as

If you can do it - do it.

opposed to a problem.) The second and much more prevelent problem is
that iirc you cannot do this kind of loose inheritance with statics in

What is 'loose inheritance'?

Stanislav Malyshev, Zend Software Architect
stas@zend.com http://www.zend.com/
(408)253-8829 MSN: stas@zend.com

18 years ago by Mike Lively — view source — reply

unread

Stanislav Malyshev wrote:

   parent::test();
What do you want parent::test() to mean?

This will echo 'A'. So like I said you have no way here of telling that
B:: was used.

Because it wasn't. parent::test() means A::test(). 'parent::' means
'parent class of the class where this statement is' in PHP. For B,
it's A.
Yes but B::test() was called to start the call chain and in this
situation I want the B::test() method to decorate A::test() and it just
isn't possible without allowing parent:: to forward the called class or
introducing a new keyword.

Then there are two problems (sort of). First problem being, then why
bother with lsb, you can do this already (which more so a 'wth' as

If you can do it - do it.
I (and many other people) don't feel the need to do things this way and
it is slightly frustrating to see a patch implemented to allow us to
'sort of' do it cleanly but ultimately misses the mark. Especially when
it is probably a relatively minor change to support what we are asking
for. This is also a terrible argument to use against a new feature...but
that's an entirely separate matter.

opposed to a problem.) The second and much more prevelent problem is
that iirc you cannot do this kind of loose inheritance with statics in

What is 'loose inheritance'?

By loose inheritance I mean extending and overwriting a method while
changing that method's parameter list.

I apologize, I grabbed php6 and appear to have not remembered things
quite right. I thought that you could not change the parameter list of
inherited static methods which is not the case in php6. Although you
WILL have a problem if you program to interfaces. If static public
test() is declared in an interface that A implements then you won't be
able to change the parameter list in B.

17 years ago by Gergely Hodicska — view source — reply

unread

Hi!

What do you want parent::test() to mean?
Because it wasn't. parent::test() means A::test(). 'parent::' means
'parent class of the class where this statement is' in PHP. For B, it's A.
When you use parent in your code you generally want to add some plus
functionality to the parent class. But in this case if you use the
parent the behavior of the parent class changes too.

Best Regards,
Felhő

17 years ago by Marco Kaiser — view source — reply

unread

Hi List,

just to drop my note here, i asked (i think) 2 years ago for such a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;

static public function getInstance()
{
    $caller = `get_called_class()`;
    if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
    }

    return static::$_instance;
}

}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some frameworks. :)
So this is one of my examples that helps much.

--
Marco Kaiser

17 years ago by Marco Kaiser — view source — reply

unread

Hi again,

to explain the main idea a bit more, the code below work and moves the
main getInstance function from the class and its possible to abstract
this.
it would be cool to get the protected property also into the abstract
class. Any idea or maybe a solution in the near future?

<?php
abstract class singleton
{
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}

    return static::$_instance;
}

}

class foo extends singleton {
static protected $_instance = null;
}

class bar extends singleton {
static protected $_instance = null;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

Hi List,

just to drop my note here, i asked (i think) 2 years ago for such a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;
    static public function getInstance()
    {
        $caller = `get_called_class()`;
        if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
        }

        return static::$_instance;
    }
}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some frameworks. :)
So this is one of my examples that helps much.

--
Marco Kaiser

--
Marco Kaiser

17 years ago by Richard Quadling — view source — reply

unread

Hi again,

to explain the main idea a bit more, the code below work and moves the
main getInstance function from the class and its possible to abstract
this.
it would be cool to get the protected property also into the abstract
class. Any idea or maybe a solution in the near future?

<?php
abstract class singleton
{
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
        return static::$_instance;
    }
}

class foo extends singleton {
static protected $_instance = null;
}

class bar extends singleton {
static protected $_instance = null;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>
Hi List,

just to drop my note here, i asked (i think) 2 years ago for such a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;
    static public function getInstance()
    {
        $caller = `get_called_class()`;
        if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
        }

        return static::$_instance;
    }
}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some frameworks. :)
So this is one of my examples that helps much.

--
Marco Kaiser
--
Marco Kaiser

<?php
abstract class singleton
{
static protected $_instance = null;
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}

       return static::$_instance;
   }

}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

object(foo)#1 (0) {
}
object(bar)#2 (0) {
}
object(foo)#1 (0) {
}
object(bar)#2 (0) {
}

in PHP 5.3.0-dev (cli) (built: Nov 20 2007 08:19:12)

I think this is great! Well done everyone. Unless I've completely
missed the point.

--

Richard Quadling
Zend Certified Engineer : http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

17 years ago by Richard Quadling — view source — reply

unread

Hi again,

to explain the main idea a bit more, the code below work and moves the
main getInstance function from the class and its possible to abstract
this.
it would be cool to get the protected property also into the abstract
class. Any idea or maybe a solution in the near future?

<?php
abstract class singleton
{
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
        return static::$_instance;
    }
}

class foo extends singleton {
static protected $_instance = null;
}

class bar extends singleton {
static protected $_instance = null;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>
Hi List,

just to drop my note here, i asked (i think) 2 years ago for such a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;
    static public function getInstance()
    {
        $caller = `get_called_class()`;
        if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
        }

        return static::$_instance;
    }
}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some frameworks. :)
So this is one of my examples that helps much.

--
Marco Kaiser
--
Marco Kaiser
<?php
abstract class singleton
{
static protected $_instance = null;
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

object(foo)#1 (0) {
}
object(bar)#2 (0) {
}
object(foo)#1 (0) {
}
object(bar)#2 (0) {
}

in PHP 5.3.0-dev (cli) (built: Nov 20 2007 08:19:12)

I think this is great! Well done everyone. Unless I've completely
missed the point.

Also, you can make the getInstance() method final so it cannot be
overridden in sub-classes...

<?php
abstract class singleton
{
static protected $_instance = null;
static final public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}

       return static::$_instance;
   }

}

class foo extends singleton {
public function getInstance() { return 'foobar'; }
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

Fatal error: Cannot override final method singleton::getInstance() in
C:\sing.php on line 18

So, a very useful addition to the language.

--

Richard Quadling
Zend Certified Engineer : http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

17 years ago by Marco Kaiser — view source — reply

unread

Hi Richard,

the problem is this:

<?php
abstract class singleton
{
static protected $_instance;

static final public function getInstance()
{
    $caller = `get_called_class()`;
    if (!static::$_instance instanceof $caller) {
        echo "NEW INSTANCE\n";
        static::$_instance = new $caller;
    }

    return static::$_instance;
}

}

class foo extends singleton {
static protected $_instance;
}

class bar extends singleton {
static protected $_instance;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

NEW INSTANCE
object(foo)#1 (0) {
}
NEW INSTANCE
object(bar)#2 (0) {
}
object(foo)#1 (0) {
}
object(bar)#2 (0) {
}

This means i just called once the constructor for the singleton abstract for every main class (foo, bar)
But if you remove the static member $_instance from the foo and bar class you get this result:

NEW INSTANCE
object(foo)#1 (0) {
}
NEW INSTANCE
object(bar)#2 (0) {
}
NEW INSTANCE
object(foo)#1 (0) {
}
NEW INSTANCE
object(bar)#2 (0) {
}

You see that the constructor is called every time if you use more than 1 singleton class during script execution.
The problem is that the property isnt really inherited by the foo and bar class.

My idea or a possible solution would be to allow the definition of correct inheritance of the $_instance property or
to show me a way to set a static property dynamicly in the caller class.
Maybe Andi or Markus can explain this a bit more why this isnt possible. :)

-- Marco

-----Original Message-----
From: Richard Quadling [mailto:rquadling@googlemail.com]
Sent: Friday, November 23, 2007 10:22 AM
To: Marco Kaiser
Cc: PHP Developers Mailing List
Subject: Re: [PHP-DEV] late static binding php6
Hi again,

to explain the main idea a bit more, the code below work and moves
the
main getInstance function from the class and its possible to
abstract
this.
it would be cool to get the protected property also into the
abstract
class. Any idea or maybe a solution in the near future?

<?php
abstract class singleton
{
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
        return static::$_instance;
    }
}

class foo extends singleton {
static protected $_instance = null;
}

class bar extends singleton {
static protected $_instance = null;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

On Nov 22, 2007 9:29 PM, Marco Kaiser marco.kaiser@gmail.com
wrote:
Hi List,

just to drop my note here, i asked (i think) 2 years ago for such
a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;
    static public function getInstance()
    {
        $caller = `get_called_class()`;
        if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
        }

        return static::$_instance;
    }
}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some
frameworks. :)
So this is one of my examples that helps much.

--
Marco Kaiser
--
Marco Kaiser
<?php
abstract class singleton
{
static protected $_instance = null;
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

object(foo)#1 (0) {
}
object(bar)#2 (0) {
}
object(foo)#1 (0) {
}
object(bar)#2 (0) {
}

in PHP 5.3.0-dev (cli) (built: Nov 20 2007 08:19:12)

I think this is great! Well done everyone. Unless I've completely
missed the point.
Also, you can make the getInstance() method final so it cannot be
overridden in sub-classes...

<?php
abstract class singleton
{
static protected $_instance = null;
static final public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}

class foo extends singleton {
public function getInstance() { return 'foobar'; }
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

Fatal error: Cannot override final method singleton::getInstance() in
C:\sing.php on line 18

So, a very useful addition to the language.

--

Richard Quadling
Zend Certified Engineer :
http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

17 years ago by Marcus Boerger — view source — reply

unread

Hello Richard,

that kind of stuff is the reason we added LSB. There is only one tiny
thing I am not to happy about. You do not at all have to declare static
$instance. Simply because you never use it. And for that reason you guys
have your code worng. Use the following snippet for verification:
var_dump($u=foo::getInstance());
var_dump($v=bar::getInstance());
var_dump($w=foo::getInstance());
var_dump($x=bar::getInstance());
var_dump(array($u,$v,$w,$x));

When you want to have a factory of singletons that can create one single
member of every derived class than you need to add an array to store those
inside the abstract base class. That also allows to make that member
private and thereby disallowing any derived class to interfere with the
static member and get rid of them to overthrow the singleton limitation...
You also have no need for the instanceof operation with the array. See here:

<?php
abstract class singleton
{
static private $instances = array();
static final public function getInstance()
{
$caller = get_called_class();
if (!isset(self::$instances[$caller])) {
self::$instances[$caller] = new $caller;
}
return self::$instances[$caller];
}
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump($u=foo::getInstance());
var_dump($v=bar::getInstance());
var_dump($w=foo::getInstance());
var_dump($x=bar::getInstance());
var_dump(array($u,$v,$w,$x));
?>

Friday, November 23, 2007, 10:21:51 AM, you wrote:

Hi again,

to explain the main idea a bit more, the code below work and moves the
main getInstance function from the class and its possible to abstract
this.
it would be cool to get the protected property also into the abstract
class. Any idea or maybe a solution in the near future?

<?php
abstract class singleton
{
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
        return static::$_instance;
    }
}

class foo extends singleton {
static protected $_instance = null;
}

class bar extends singleton {
static protected $_instance = null;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>
Hi List,

just to drop my note here, i asked (i think) 2 years ago for such a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;
    static public function getInstance()
    {
        $caller = `get_called_class()`;
        if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
        }

        return static::$_instance;
    }
}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some frameworks.
So this is one of my examples that helps much.

--
Marco Kaiser
--
Marco Kaiser
<?php
abstract class singleton
{
static protected $_instance = null;
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

object(foo)#1 (0) {
}
object(bar)#2 (0) {
}
object(foo)#1 (0) {
}
object(bar)#2 (0) {
}

in PHP 5.3.0-dev (cli) (built: Nov 20 2007 08:19:12)

I think this is great! Well done everyone. Unless I've completely
missed the point.

Also, you can make the getInstance() method final so it cannot be
overridden in sub-classes...

<?php
abstract class singleton
{
static protected $_instance = null;
static final public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}

       return static::$_instance;
   }

}

class foo extends singleton {
public function getInstance() { return 'foobar'; }
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>>

returns ...

Fatal error: Cannot override final method singleton::getInstance() in
C:\sing.php on line 18

So, a very useful addition to the language.

--

Richard Quadling
Zend Certified Engineer : http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

Best regards,
Marcus

17 years ago by Richard Quadling — view source — reply

unread

Hello Richard,

that kind of stuff is the reason we added LSB. There is only one tiny
thing I am not to happy about. You do not at all have to declare static
$instance. Simply because you never use it. And for that reason you guys
have your code worng. Use the following snippet for verification:
var_dump($u=foo::getInstance());
var_dump($v=bar::getInstance());
var_dump($w=foo::getInstance());
var_dump($x=bar::getInstance());
var_dump(array($u,$v,$w,$x));

When you want to have a factory of singletons that can create one single
member of every derived class than you need to add an array to store those
inside the abstract base class. That also allows to make that member
private and thereby disallowing any derived class to interfere with the
static member and get rid of them to overthrow the singleton limitation...
You also have no need for the instanceof operation with the array. See here:

<?php
abstract class singleton
{
static private $instances = array();
static final public function getInstance()
{
$caller = get_called_class();
if (!isset(self::$instances[$caller])) {
self::$instances[$caller] = new $caller;
}
return self::$instances[$caller];
}
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump($u=foo::getInstance());
var_dump($v=bar::getInstance());
var_dump($w=foo::getInstance());
var_dump($x=bar::getInstance());
var_dump(array($u,$v,$w,$x));
?>

Changing bar to extend from foo gives the same results.

We have a singleton of the class bar because somewhere in the chain it
has the singleton class.

Excellent.

Friday, November 23, 2007, 10:21:51 AM, you wrote:
Hi again,

to explain the main idea a bit more, the code below work and moves the
main getInstance function from the class and its possible to abstract
this.
it would be cool to get the protected property also into the abstract
class. Any idea or maybe a solution in the near future?

<?php
abstract class singleton
{
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
        return static::$_instance;
    }
}

class foo extends singleton {
static protected $_instance = null;
}

class bar extends singleton {
static protected $_instance = null;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>
Hi List,

just to drop my note here, i asked (i think) 2 years ago for such a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;
    static public function getInstance()
    {
        $caller = `get_called_class()`;
        if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
        }

        return static::$_instance;
    }
}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some frameworks.
So this is one of my examples that helps much.

--
Marco Kaiser
--
Marco Kaiser
<?php
abstract class singleton
{
static protected $_instance = null;
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

object(foo)#1 (0) {
}
object(bar)#2 (0) {
}
object(foo)#1 (0) {
}
object(bar)#2 (0) {
}

in PHP 5.3.0-dev (cli) (built: Nov 20 2007 08:19:12)

I think this is great! Well done everyone. Unless I've completely
missed the point.
Also, you can make the getInstance() method final so it cannot be
overridden in sub-classes...

<?php
abstract class singleton
{
static protected $_instance = null;
static final public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}
class foo extends singleton {
public function getInstance() { return 'foobar'; }
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>>

returns ...

Fatal error: Cannot override final method singleton::getInstance() in
C:\sing.php on line 18

So, a very useful addition to the language.

--

Richard Quadling
Zend Certified Engineer : http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

Best regards,
Marcus

--

Richard Quadling
Zend Certified Engineer : http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

17 years ago by Marcus Boerger — view source — reply

unread

Hello Richard,

what's your point? The output of this script with updated checks and
inheritence still gives expected results:
<?php
abstract class singleton
{
static private $instances = array();
static final public function getInstance()
{
$caller = get_called_class();
if (!self::$instances[$caller] instanceof $caller) {
self::$instances[$caller] = new $caller;
}
return self::$instances[$caller];
}
}

class foo extends singleton {
}

class bar extends singleton {
}

class baz extends bar {
}

var_dump($u = foo::getInstance());
var_dump($v = bar::getInstance());
var_dump($w = baz::getInstance());

var_dump($x = foo::getInstance());
var_dump($y = bar::getInstance());
var_dump($z = baz::getInstance());

var_dump(array($u, $v, $w, $x, $y, $z));
?>

If you wanted to prevent further inheritance you'd simply mark the class as
final. Say 'final class bar' would prevent existance of 'baz'. I wonder if
we shouldn't make this somehow into a testcase so that we know the desired
behavior stays as development of LSB continues.

marcus

Friday, November 23, 2007, 1:26:37 PM, you wrote:

Hello Richard,

that kind of stuff is the reason we added LSB. There is only one tiny
thing I am not to happy about. You do not at all have to declare static
$instance. Simply because you never use it. And for that reason you guys
have your code worng. Use the following snippet for verification:
var_dump($u=foo::getInstance());
var_dump($v=bar::getInstance());
var_dump($w=foo::getInstance());
var_dump($x=bar::getInstance());
var_dump(array($u,$v,$w,$x));

When you want to have a factory of singletons that can create one single
member of every derived class than you need to add an array to store those
inside the abstract base class. That also allows to make that member
private and thereby disallowing any derived class to interfere with the
static member and get rid of them to overthrow the singleton limitation...
You also have no need for the instanceof operation with the array. See here:

<?php
abstract class singleton
{
static private $instances = array();
static final public function getInstance()
{
$caller = get_called_class();
if (!isset(self::$instances[$caller])) {
self::$instances[$caller] = new $caller;
}
return self::$instances[$caller];
}
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump($u=foo::getInstance());
var_dump($v=bar::getInstance());
var_dump($w=foo::getInstance());
var_dump($x=bar::getInstance());
var_dump(array($u,$v,$w,$x));
?>

Changing bar to extend from foo gives the same results.

We have a singleton of the class bar because somewhere in the chain it
has the singleton class.

Excellent.

Friday, November 23, 2007, 10:21:51 AM, you wrote:
Hi again,

to explain the main idea a bit more, the code below work and moves the
main getInstance function from the class and its possible to abstract
this.
it would be cool to get the protected property also into the abstract
class. Any idea or maybe a solution in the near future?

<?php
abstract class singleton
{
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
        return static::$_instance;
    }
}

class foo extends singleton {
static protected $_instance = null;
}

class bar extends singleton {
static protected $_instance = null;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>
Hi List,

just to drop my note here, i asked (i think) 2 years ago for such a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;
    static public function getInstance()
    {
        $caller = `get_called_class()`;
        if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
        }

        return static::$_instance;
    }
}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some frameworks.
So this is one of my examples that helps much.

--
Marco Kaiser
--
Marco Kaiser
<?php
abstract class singleton
{
static protected $_instance = null;
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

object(foo)#1 (0) {
}
object(bar)#2 (0) {
}
object(foo)#1 (0) {
}
object(bar)#2 (0) {
}

in PHP 5.3.0-dev (cli) (built: Nov 20 2007 08:19:12)

I think this is great! Well done everyone. Unless I've completely
missed the point.
Also, you can make the getInstance() method final so it cannot be
overridden in sub-classes...

<?php
abstract class singleton
{
static protected $_instance = null;
static final public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}
class foo extends singleton {
public function getInstance() { return 'foobar'; }
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>>

returns ...

Fatal error: Cannot override final method singleton::getInstance() in
C:\sing.php on line 18

So, a very useful addition to the language.

--

Richard Quadling
Zend Certified Engineer : http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

Best regards,
Marcus

--

Richard Quadling
Zend Certified Engineer : http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

Best regards,
Marcus

17 years ago by Marco Kaiser — view source — reply

unread

Hi Marcus,

ahh now i know whats my thinking problem. :) the new introduced function
get_called_class() function gives me the
information how to work around my problem. :) static isnt really required.
:)

-- Marco

-----Original Message-----
From: Marcus Boerger [mailto:helly@php.net]
Sent: Friday, November 23, 2007 12:23 PM
To: Richard Quadling
Cc: Marco Kaiser; PHP Developers Mailing List
Subject: Re: [PHP-DEV] late static binding php6

Hello Richard,

that kind of stuff is the reason we added LSB. There is only one tiny
thing I am not to happy about. You do not at all have to declare static
$instance. Simply because you never use it. And for that reason you
guys
have your code worng. Use the following snippet for verification:
var_dump($u=foo::getInstance());
var_dump($v=bar::getInstance());
var_dump($w=foo::getInstance());
var_dump($x=bar::getInstance());
var_dump(array($u,$v,$w,$x));

When you want to have a factory of singletons that can create one
single
member of every derived class than you need to add an array to store
those
inside the abstract base class. That also allows to make that member
private and thereby disallowing any derived class to interfere with the
static member and get rid of them to overthrow the singleton
limitation...
You also have no need for the instanceof operation with the array. See
here:

<?php
abstract class singleton
{
static private $instances = array();
static final public function getInstance()
{
$caller = get_called_class();
if (!isset(self::$instances[$caller])) {
self::$instances[$caller] = new $caller;
}
return self::$instances[$caller];
}
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump($u=foo::getInstance());
var_dump($v=bar::getInstance());
var_dump($w=foo::getInstance());
var_dump($x=bar::getInstance());
var_dump(array($u,$v,$w,$x));
?>

Friday, November 23, 2007, 10:21:51 AM, you wrote:
Hi again,

to explain the main idea a bit more, the code below work and moves
the
main getInstance function from the class and its possible to
abstract
this.
it would be cool to get the protected property also into the
abstract
class. Any idea or maybe a solution in the near future?

<?php
abstract class singleton
{
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
        return static::$_instance;
    }
}

class foo extends singleton {
static protected $_instance = null;
}

class bar extends singleton {
static protected $_instance = null;
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

On Nov 22, 2007 9:29 PM, Marco Kaiser marco.kaiser@gmail.com
wrote:
Hi List,

just to drop my note here, i asked (i think) 2 years ago for
such a
feature to automate my singleton pattern. Not with late static
bindings this is possible.

<?php
class singleton
{
static protected $_instance = null;
    static public function getInstance()
    {
        $caller = `get_called_class()`;
        if (!static::$_instance instanceof $caller) {
        static::$_instance = new $caller;
        }

        return static::$_instance;
    }
}

class foo extends singleton
{
}

var_dump(foo::getInstance());
var_dump(foo::getInstance());
?>

i think this will also drop much redundant code from some
frameworks.
So this is one of my examples that helps much.

--
Marco Kaiser
--
Marco Kaiser
<?php
abstract class singleton
{
static protected $_instance = null;
static public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}

class foo extends singleton {
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>

returns ...

object(foo)#1 (0) {
}
object(bar)#2 (0) {
}
object(foo)#1 (0) {
}
object(bar)#2 (0) {
}

in PHP 5.3.0-dev (cli) (built: Nov 20 2007 08:19:12)

I think this is great! Well done everyone. Unless I've completely
missed the point.
Also, you can make the getInstance() method final so it cannot be
overridden in sub-classes...

<?php
abstract class singleton
{
static protected $_instance = null;
static final public function getInstance()
{
$caller = get_called_class();
if (!static::$_instance instanceof $caller) {
static::$_instance = new $caller;
}
       return static::$_instance;
   }
}
class foo extends singleton {
public function getInstance() { return 'foobar'; }
}

class bar extends singleton {
}

var_dump(foo::getInstance());
var_dump(bar::getInstance());
var_dump(foo::getInstance());
var_dump(bar::getInstance());
?>>

returns ...

Fatal error: Cannot override final method singleton::getInstance() in
C:\sing.php on line 18

So, a very useful addition to the language.

--

Richard Quadling
Zend Certified Engineer :
http://zend.com/zce.php?c=ZEND002498&r=213474731
"Standing on the shoulders of some very clever giants!"

Best regards,
Marcus

17 years ago by Jeff Moore — view source — reply

unread

Hi,

May I suggest renaming get_called_class() to get_static_class() to
correspond with the use of the static:: keyword for late binding.

parent:: and get_parent_class() [no parameters] should also correspond
when used in a static method context.

My preference is that parent:: be late binding. I would also like to
see an early bound parent constant along the lines of class.

Best Regards,

Jeff

17 years ago by Etienne Kneuss — view source — reply

unread

Hi,

Hi,

May I suggest renaming get_called_class() to get_static_class() to
correspond with the use of the static:: keyword for late binding.

It was already kind of discussed, and get_called_class makes more sense IMO.
"static class" is not self-descriptive. The class returned is the class that
was initially
referenced for the call, as in the class "called" initially.

parent:: and get_parent_class() [no parameters] should also correspond
when used in a static method context.

They do, parent::foo(); should be the same as $class = get_parent_class();
$class::foo();

Of course, we can't make parent:: reference the parent class of the called
one, as it would break BC.

As in:
class A { }
class B extends A { public static function test() { echo get_class(new
parent), '-', get_parent_class(); } }
class C extends B { }
C::test(); // A-A and not B-B

My preference is that parent:: be late binding. I would also like to
see an early bound parent constant along the lines of class.

Best Regards,

Jeff

--

--
Etienne Kneuss
http://www.colder.ch

Men never do evil so completely and cheerfully as
when they do it from a religious conviction.
-- Pascal

17 years ago by Gergely Hodicska — view source — reply

unread

Hi!

Of course, we can't make parent:: reference the parent class of the called
one, as it would break BC.

As in:
class A { }
class B extends A { public static function test() { echo get_class(new
parent), '-', get_parent_class(); } }
class C extends B { }
C::test(); // A-A and not B-B
Maybe you missed the point, nobody wants that this code should return
B-B, the only difference is in the return value of the
get_called_class() function (which is not exists yet, so there is no BC).

Best Regards,
Felhő

17 years ago by Mike Lively — view source — reply

unread

I have come up with three different patches that allow us to work around
the issue of parent:: being considered an 'explicit class reference' and
thus disallowing static:: to effectively used.

The patches are against 5.3. I also have patches against HEAD but I was
having problems getting run-tests.php to run against that code base (it
would hang on the first test no matter which set of tests I ws running.)

All three patches have different levels of intrusiveness to the engine
and all three patches have been tested against (and pass) the existing
lsb tests in Zend/tests/lsb_*.phpt

1.) lsb.parent-forwarding.patch
This patch modifies the behavior of only parent:: to not change
EG(called_class) to the parent of the current scope. With this change.

<?php

class A {
public static function test() {
echo get_called_class()."\n";
}
}

class B extends A {
public static function test() {
parent::test();
}
}

A::test();
B::test();

?>
will output:
A
B

It should be noticed that with this patch parent:: will always resolve
to the parent of the current scope, it will just not make any changes to
the called_scope (effectively)

2.) lsb.new-keyword.patch
This patch effectively does the same thing as the parent forwarding
patch, but does it by introducing a new keyword. I had no idea what to
call this keyword so for the time being I am using '__parentf'. If this
is a direction people want to go this can of course be changed with a
relatively simple search & replace in the patch file.

The code above would need to be changed to:

<?php

class A {
public static function test() {
echo get_called_class()."\n";
}
}

class B extends A {
public static function test() {
__parentf::test();
}
}

A::test();
B::test();

This patch carries the same costs as the parent forwarding patch with
the additional costs of having to check for a new keyword when declaring
classes/namespaces/interfaces and calling static methods. Perhaps
someone knows a cheaper way to do this?

3.) lsb.forward_static_call.patch
This patch implements my desired functionality by using two new
functions: forward_static_call() and forward_static_call_array(). These
functions ares similar to the call_user_func*() functions however the
first parameter is not a callback but a string specifying the desired
static method that exists in the current scope's parent class. The
function will error out with messages similar to parent:: if called from
outside of a class or from within a class that does not have a parent.

So with this patch the code would change to:

<?php

class A {
public static function test() {
echo get_called_class()."\n";
}
}

class B extends A {
public static function test() {
forward_static_call(FUNCTION);
}
}

A::test();
B::test();

This patch is completely outside of the Zend engine and as such existing
lsb functionality is not affected at all.

So, with these three options on the table I think it is very clear that
what we are asking for can be done with varying levels of
'intrusiveness', so what does everyone think?

If one of these options looks worth pursuing I can put together the
tests I have written for all of them, cleanup the code, help with
documentation, etc.

Mike Lively
http://www.digitalsandwich.com

17 years ago by Alexey Zakhlestin — view source — reply

unread

I have come up with three different patches that allow us to work around
the issue of parent:: being considered an 'explicit class reference' and
thus disallowing static:: to effectively used.

The patches are against 5.3. I also have patches against HEAD but I was
having problems getting run-tests.php to run against that code base (it
would hang on the first test no matter which set of tests I ws running.)

All three patches have different levels of intrusiveness to the engine
and all three patches have been tested against (and pass) the existing
lsb tests in Zend/tests/lsb_*.phpt

1.) lsb.parent-forwarding.patch
This patch modifies the behavior of only parent:: to not change
EG(called_class) to the parent of the current scope. With this change.

<?php

class A {
public static function test() {
echo get_called_class()."\n";
}
}

class B extends A {
public static function test() {
parent::test();
}
}

A::test();
B::test();

?>
will output:
A
B

It should be noticed that with this patch parent:: will always resolve
to the parent of the current scope, it will just not make any changes to
the called_scope (effectively)

I believe this first patch is the proper way to go. It feels
"natural", "intuitive", etc.

--
Alexey Zakhlestin
http://blog.milkfarmsoft.com/

17 years ago by Stanislav Malyshev — view source — reply

unread

I believe this first patch is the proper way to go. It feels
"natural", "intuitive", etc.

I don't see how making parent::foo() and A::foo() work differently is
either "natural" or "intuitive".

Stanislav Malyshev, Zend Software Architect
stas@zend.com http://www.zend.com/
(408)253-8829 MSN: stas@zend.com

17 years ago by Alexey Zakhlestin — view source — reply

unread

I believe this first patch is the proper way to go. It feels
"natural", "intuitive", etc.

I don't see how making parent::foo() and A::foo() work differently is
either "natural" or "intuitive".

A::foo() doesn't mean any inheritance at all. "A" can be completely
unrelated class

parent::foo() means inheritance and inheritance means "extending" and
"keeping context". So, "parent::foo()" means "call method of
parent-class, but remember, that we extended that class, so keep
context"

--
Alexey Zakhlestin
http://blog.milkfarmsoft.com/

17 years ago by Elizabeth Smith — view source — reply

unread

Alexey Zakhlestin wrote:

I have come up with three different patches that allow us to work around
the issue of parent:: being considered an 'explicit class reference' and
thus disallowing static:: to effectively used.

The patches are against 5.3. I also have patches against HEAD but I was
having problems getting run-tests.php to run against that code base (it
would hang on the first test no matter which set of tests I ws running.)

All three patches have different levels of intrusiveness to the engine
and all three patches have been tested against (and pass) the existing
lsb tests in Zend/tests/lsb_*.phpt

1.) lsb.parent-forwarding.patch
This patch modifies the behavior of only parent:: to not change
EG(called_class) to the parent of the current scope. With this change.

<?php

class A {
public static function test() {
echo get_called_class()."\n";
}
}

class B extends A {
public static function test() {
parent::test();
}
}

A::test();
B::test();

?>
will output:
A
B

It should be noticed that with this patch parent:: will always resolve
to the parent of the current scope, it will just not make any changes to
the called_scope (effectively)

I believe this first patch is the proper way to go. It feels
"natural", "intuitive", etc.

I also think this is the proper way to handle parent:: in a static
context - I shudder to think of the number of "bogus" bug reports
that'll pop up if lsb DOESN'T work this way.

People using a parent:: call in a class don't think of it as static,
they think of it as call the class that this one extends, where as a
explicit Class::method(); call means "call this static method", so they
expect them to work differently.

17 years ago by dz@bitxtender.com — view source — reply

unread

Am 26.11.2007 um 10:24 schrieb Alexey Zakhlestin:

class A {
public static function test() {
echo get_called_class()."\n";
}
}

class B extends A {
public static function test() {
parent::test();
}
}

A::test();
B::test();

will output:
A
B
I believe this first patch is the proper way to go. It feels
"natural", "intuitive", etc.

Definitely. However, given the arguments here, I was thinking this:

static always points to the original callee, w/o being "broken" by
parent::
get_called_class() should not behave like shown above. It really
was not B that got called, but it was A, trough parent::
a new get_static_class() method should return "B".

(essentially, get_called_class() returns the name of "self", while
get_static_class() returns the name of "static").

So:

class A {
public static function test() {
echo get_called_class() . get_static_class();
}
}

class B extends A {
public static function test() {
parent::test();
}
}

outputs:
AAAB

David

17 years ago by Stanislav Malyshev — view source — reply

unread

static always points to the original callee, w/o being "broken" by
parent::

get_called_class() should not behave like shown above. It really was
not B that got called, but it was A, trough parent::

a new get_static_class() method should return "B".

Ouch. So now not only we have parent:: and Class:: behave differently
(and I'm afraid to think of how call_user_func() should work) we also
have two separate functions for getting called class and only one of
them has non-functional notation. Yes, this is natural and intuitive. Not.

(essentially, get_called_class() returns the name of "self", while

You don't need a function to get "self". You have CLASS for that.

Stanislav Malyshev, Zend Software Architect
stas@zend.com http://www.zend.com/
(408)253-8829 MSN: stas@zend.com

17 years ago by dz@bitxtender.com — view source — reply

unread

Am 26.11.2007 um 19:13 schrieb Stanislav Malyshev:

static always points to the original callee, w/o being "broken"
by parent::

get_called_class() should not behave like shown above. It
really was not B that got called, but it was A, trough parent::

a new get_static_class() method should return "B".

Ouch. So now not only we have parent:: and Class:: behave
differently (and I'm afraid to think of how call_user_func() should
work) we also have two separate functions for getting called class
and only one of them has non-functional notation. Yes, this is
natural and intuitive. Not.

(essentially, get_called_class() returns the name of "self", while

You don't need a function to get "self". You have CLASS for that.

Ah. Right. Didn't think of that. Well, then, get_called_class() should
of course maintain the context (i.e. return the original callee) even
with parent::

David

17 years ago by m@digitalsandwich.com — view source — reply

unread

static always points to the original callee, w/o being "broken" by
parent::

get_called_class() should not behave like shown above. It really was
not B that got called, but it was A, trough parent::

a new get_static_class() method should return "B".

Ouch. So now not only we have parent:: and Class:: behave differently
(and I'm afraid to think of how call_user_func() should work) we also
have two separate functions for getting called class and only one of
them has non-functional notation. Yes, this is natural and intuitive. Not.

I don't think we need this, like you mentioned we have CLASS, we also
have get_class(). call_user_func() works fine in the patches...was a pita
:P but it works fine.

Mike Lively

late static binding php6

It will be, just not by means of parent::.

Yes, this is exactly what LSB does.

What is 'loose inheritance'?

--

--

--

--

--

--

--

--

--

I don't see how making parent::foo() and A::foo() work differently is either "natural" or "intuitive".

You don't need a function to get "self". You have CLASS for that.

I don't see how making parent::foo() and A::foo() work differently is
either "natural" or "intuitive".