Jochem Maas wrote:
Bart de Boer wrote:
Ken Stanley wrote:
...
That's not right. Accessing the child class would only be possible from
within an instantiated object. Unlike parent::, you will never be able
to use static:: in a purely static context. Imagine there are multiple
child classes which all inherit from the same base class. If there's no
instance, PHP won't be able to know which child class to target with
child::, static:: or whateverkeyword:: since it can be any one of those
child classes.
huh??? the 'child' class would refer to the class that was actually named
when then call to the method was made (thats what late static binding means,
does it not?):
class Data {
static function getTableName() {
throw new Exception('WTF');
}
static function findRange() {
$t = child::getTableName();
}
}
class Prod {
static function getTableName() {
return 'PRODS';
}
}
Data::findRange(); // child = Data class
Prod::findRange(); // child = Prod class
if you require a class instance in order to use 'child' then
the whole point is moot - because you can already do
$child = get_class($this);
inside the relevant function (assuming the function is not declared static,
and why would you declare it as such if your requiring an instance to use
'child'?).
maybe 'child' should be called 'callee' or even 'lsb' (that would make people
hit the docs for sure :-)). alternatively maybe 'this' could be used as the LSB
keyword:
this::foo();
the samentics for determining what class is referred to with 'this::' is akin to
that used for determining what class is referred with '$this->', no?
MAYBE php6 should do late static binding for 'self', akin to other OO oriented
scripting langs .. and just live with BC. I seriously wonder whether much code
would
break ... given that 'self' is not currently late binding how often would
people have actually
overwritten static methods ion child classes that are being called via the
'self' syntax
in [parent] classes?
Hello,
In an instance, fetching the class and running call_user_func is quite
overkill, hopefully the dynamic access of class method/member/const will
get accepted/commited. There is no reason (implementation wise) to
restrict LSB to static callstacks only.
By the way, "child" is not a good term either as it won't always
represent the child, i.e. the class itself.
Changing the behavior of "self" seems like a bad idea, it will make
every script using "self" (many) rely on the call stack, which will
among other things break BC and slow things down.
--
Etienne Kneuss
http://www.colder.ch
[EMAIL PROTECTED]
Men never do evil so completely and cheerfully as
when they do it from a religious conviction.
-- Pascal
--
PHP Internals - PHP Runtime Development Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
