Hi,
Is there a chance to have annotations like in Java or like .NET attributes?
Now, I use Java Annotations emulation, through Reflections and PHPDoc
blocks. Example:
/** Annotation One*/
class DemoAnnotation1 extends C01t_Annotation
{
public $value;
}
/** Annotation Two*/
class DemoAnnotation2 extends C01t_Annotation
{
public $p1;
public $p2;
}
class DemoClass
{
const SOME_CONST = 5;
/** @DemoAnnotation1(DemoClass::SOME_CONST + 1) */
public $property1;
/** @DemoAnnotation2(p1 => 1, p2 => 'Hello, Word!') */
public $property2;
}
Thanks,
Volodymyr Iatsyshyn
Hello Volodymyr,
Tuesday, August 19, 2008, 3:54:16 PM, you wrote:
Hi,
Is there a chance to have annotations like in Java or like .NET attributes?
Now, I use Java Annotations emulation, through Reflections and PHPDoc
blocks. Example:
/** Annotation One*/
class DemoAnnotation1 extends C01t_Annotation
{
public $value;
}
/** Annotation Two*/
class DemoAnnotation2 extends C01t_Annotation
{
public $p1;
public $p2;
}
class DemoClass
{
const SOME_CONST = 5;
/** @DemoAnnotation1(DemoClass::SOME_CONST + 1) */ public $property1;
/** @DemoAnnotation2(p1 => 1, p2 => 'Hello, Word!') */ public $property2;}
Basically there is no need for annotations in PHP unlike there is in Python
for instance. However, while the following work:
php -r 'class T { const C=42; var $p=T::C; } var_dump(new T);'
php -r 'class T { const C=42; const D=T::C; } var_dump(new T);
the next two do not:
php -r 'class T { const C=42; var $p=T::C + 1; } var_dump(new T);'
php -r 'class T { const C=42; const D=T::C + 1; } var_dump(new T);
So you might want to have full support for evaluated consts/default values.
The reason why we do not support this right now is a limitation in how
consts and default values get initialised.
Best regards,
Marcus
W liście Marcus Boerger z dnia środa, 20 sierpnia 2008:
Hello Volodymyr,
Basically there is no need for annotations in PHP unlike there is in Python
for instance. However, while the following work:
php -r 'class T { const C=42; var $p=T::C; } var_dump(new T);'
php -r 'class T { const C=42; const D=T::C; } var_dump(new T);
the next two do not:
php -r 'class T { const C=42; var $p=T::C + 1; } var_dump(new T);'
php -r 'class T { const C=42; const D=T::C + 1; } var_dump(new T);So you might want to have full support for evaluated consts/default values.
I don't really get your point. Annotations are not about constant values, but
about adding arbitrary attributes to classes and methods/functions.
A simple use case (in pseudocode):
class MyController extends BaseController {
// www.example.com/index
@allow('any')
@method('get')
public function index() {
}
// www.example.com/comment
@allow('any')
@method('post')
public function comment() {
}
// www.example.com/admin
@allow('admin')
@method('get')
public function admin() {
}
}
class BaseController {
public function _execute() {
$action = $this->parseTheUrl();
$method = new ReflectionMethod($this, $action);
if ($method->annotations('method') != $_SERVER['REQUEST_METHOD']) {
return $this->methodNotAllowed();
} elseif (! $this->currentUser->hasPrivilege($method->annotations('allow')) {
return $this->forbidden();
} else {
return $this->$action();
}
}
}
Python does not need annotations, as functions can have arbitrary attribute
set:
def a():
pass
a.x = 5
It also has very powerful mechanism of decorators, which are basically
higher-order functions applied to functions on their definition, but I don't
think Volodymyr asks for so much.
--
Paweł Stradomski
Now I use emulation of Java Annotations. I wrote simple class, that uses
PHPDoc block, gets annotations declarations and their arguments, uses
eval() to convert arguments string to array, then I create instance of
class and assigns parameters. This solution is fine just now, but it
will be very cool to have annotations as language feature. I'm pretty
sure that lots of frameworks would like this feature :-)
Paweł Stradomski wrote:
W liście Marcus Boerger z dnia środa, 20 sierpnia 2008:
Hello Volodymyr,
Basically there is no need for annotations in PHP unlike there is in Python
for instance. However, while the following work:
php -r 'class T { const C=42; var $p=T::C; } var_dump(new T);'
php -r 'class T { const C=42; const D=T::C; } var_dump(new T);
the next two do not:
php -r 'class T { const C=42; var $p=T::C + 1; } var_dump(new T);'
php -r 'class T { const C=42; const D=T::C + 1; } var_dump(new T);So you might want to have full support for evaluated consts/default values.
I don't really get your point. Annotations are not about constant values, but
about adding arbitrary attributes to classes and methods/functions.A simple use case (in pseudocode):
class MyController extends BaseController {
// www.example.com/index
@allow('any')
@method('get')
public function index() {
}// www.example.com/comment
@allow('any')
@method('post')
public function comment() {
}// www.example.com/admin
@allow('admin')
@method('get')
public function admin() {
}
}class BaseController {
public function _execute() {
$action = $this->parseTheUrl();
$method = new ReflectionMethod($this, $action);
if ($method->annotations('method') != $_SERVER['REQUEST_METHOD']) {
return $this->methodNotAllowed();
} elseif (! $this->currentUser->hasPrivilege($method->annotations('allow')) {
return $this->forbidden();
} else {
return $this->$action();
}
}
}Python does not need annotations, as functions can have arbitrary attribute
set:def a():
passa.x = 5
It also has very powerful mechanism of decorators, which are basically
higher-order functions applied to functions on their definition, but I don't
think Volodymyr asks for so much.
W liście Volodymyr Iatsyshyn z dnia czwartek 21 sierpnia 2008:
Now I use emulation of Java Annotations. I wrote simple class, that uses
PHPDoc block, gets annotations declarations and their arguments, uses
eval() to convert arguments string to array, then I create instance of
class and assigns parameters. This solution is fine just now, but it
will be very cool to have annotations as language feature. I'm pretty
sure that lots of frameworks would like this feature :-)
I understand, as I'm simulating those myself (although in a different way).
But we'd love annotations for situations such as the one I presented before,
as well as WSDL generation etc.
Instead of using annotations we use something like that:
class X {
public static myMethod_methods = array('POST', 'GET');
public static myMethod_access = 'any';
public function myMethod() {....}
}
--
Paweł Stradomski
Volodymyr Iatsyshyn wrote:
Hi,
Is there a chance to have annotations like in Java or like .NET attributes?
Now, I use Java Annotations emulation, through Reflections and PHPDoc
blocks. Example:/** Annotation One*/
class DemoAnnotation1 extends C01t_Annotation
{
public $value;
}/** Annotation Two*/
class DemoAnnotation2 extends C01t_Annotation
{
public $p1;
public $p2;
}class DemoClass
{
const SOME_CONST = 5;/** @DemoAnnotation1(DemoClass::SOME_CONST + 1) */ public $property1; /** @DemoAnnotation2(p1 => 1, p2 => 'Hello, Word!') */ public $property2;}
Thanks,
Volodymyr Iatsyshyn
So is there a chance to have these?
So is there a chance to have these?
Volodymyr, there is very little sense in such questions.
If you really think feature XXX is that useful - care to demonstrate it's
usefulness to others, "promote" it so that people start liking the idea of having it.
If you don't think you can manage writing the patch yourself, by promoting
this feature you can find a person amongst the people who could do it for you.
In any case, the process of getting any feature implemented in PHP does not finish
after someone says "ok, let's add it", in most cases there is a lot of work
to be done, and writing a very detailed RFC in the Wiki would be very good start.
Also (I have to say it..) we do accept patches.
--
Wbr,
Antony Dovgal