| Next revision | Previous revision |
| rfc:object_cast_magic [2012/02/29 02:16] – created ircmaxell | rfc:object_cast_magic [2017/09/22 13:28] (current) – external edit 127.0.0.1 |
|---|
| ===== Request for Comments: Weak References ===== | ===== Request for Comments: Object Cast and Assign Magic Methods ===== |
| * Version: 0.1 | * Version: 0.1 |
| * Date: 2012-02-28 | * Date: 2012-02-28 |
| * Author: Anthony Ferrara <ircmaxell@php.net> | * Author: Anthony Ferrara <ircmaxell@php.net> |
| * Status: In Draft | * Status: Withdrawn |
| | |
| | Note that this RFC has been withdrawn in favor of the updated https://wiki.php.net/rfc/object_cast_to_types RFC (due to feedback from several developers). |
| |
| ===== Introduction ===== | ===== Introduction ===== |
| Currently, the Zend Engine exposes several methods to PECL extensions and internal classes to control how internal objects behave when casting to primitives, and when assigning to the variable that used to hold the object. The three methods are specifically //cast_object()//, //get()// and //set()//. This proposal is to expose those three methods as two magic methods to allow user classes to hook into this functionality. | Currently, the Zend Engine exposes several methods to PECL extensions and internal classes to control how internal objects behave when casting to primitives, and when assigning to the variable that used to hold the object. The three methods are specifically //cast_object()//, //get()// and //set()//. This proposal is to expose those three methods as two magic methods to allow user classes to hook into this functionality. |
| |
| | It should be noted, that this requires no engine changes to implement. All it is doing is exposing three engine handlers that are already existing and functioning for internal classes to userland classes via magic methods. Therefore, there really is no new significant functionality, other than allowing userland code to implement the handlers. |
| ===== Use Cases ===== | ===== Use Cases ===== |
| |
| * Creating new semi-primitive types with functional limitations applied. An example would be the ability to create an integer type that is always less than a configured maximum. Another example would be to create a string type that self-prevents invalid characters (by regex, or otherwise)... | * Creating new semi-primitive types with functional limitations applied. An example would be the ability to create an integer type that is always less than a configured maximum. Another example would be to create a string type that self-prevents invalid characters (by regex, or otherwise)... |
| * Creating constant (const) variables that can be written to once (on creation), but not again. (this is sort-of not true, since you can still manually unset() the variable, but it would prevent accidental overwriting) | * Creating constant (const) variables that can be written to once (on creation), but not again. (this is sort-of not true, since you can still manually unset() the variable, but it would prevent accidental overwriting) |
| | |
| | ==== Boolean Logic ==== |
| | |
| | Right now, when you use an object in a boolean context, it always evaluates to //TRUE//. By overloading the castTo with boolean type, you can have the object return as true or false. This can be used for implementing validators that can be checked with a simple //if ($valid)// instead of having to proxy to a method. |
| |
| ==== Providing Backwards Compatibility ==== | ==== Providing Backwards Compatibility ==== |
| bool __assign(mixed $newValue) | bool __assign(mixed $newValue) |
| |
| When the cast_object handler is called, the __castTo method is invoked with a string representation of the type to be casted to. The return value is then used as the "casted" value. | ==== Handler Behavior ==== |
| | |
| | When the cast_object handler is called, the //castTo// method is invoked with a string representation of the type to be casted to. The return value is then used as the "casted" value. This would be called when explicitly cast (using //(int)// style syntax), when implicitly cast (passing as a parameter to an internal function expecting a specific type parameter) and when casted to a string (echo $obj;). |
| | |
| | When the get handler is called, the //castTo// method is invoked with the parameter "//native//". This would indicate that the cast is to a scalar, but the type is up to the class to determine. This is called when a primitive type is needed, but not a specific one. So the normal math operators trigger a get call: (+, -, *, /), in addition to compound operators (++, +=, &=, |=, etc). |
| | |
| | When the set handler is called, the //assign// method is invoked with the parameter of the new value. The object can then react to this assignment (by setting a new internal state, by throwing an exception, etc). If the object wants to be overwritten, it can return //FALSE//, which will cause the default assignment handler (overwriting the object) to happen. |
| | |
| | ==== Example Triggers ==== |
| | |
| | <?php |
| | |
| | $obj++; // triggers __castTo("native"), followed by __assign($result_from_cast + 1) |
| | $obj = $obj + 1; // same as above |
| | $obj |= 5; // triggers __castTo("native"), followed by __assign($result_from_cast | 5) |
| | |
| | $obj = 5; // triggers __assign(5) |
| | $obj = array(1, 2, 3); // triggers __assign(array(1, 2, 3)) |
| | $obj = new StdClass; // triggers __assign(new StdClass) |
| | |
| | if ($obj) // triggers __castTo("boolean") |
| | |
| |
| A proof of concept patch is available here: [[https://gist.github.com/1929587]] (note, this is a POC **ONLY**, there are issues with it, such as memory leaks). | A proof of concept patch is available here: [[https://gist.github.com/1929587]] (note, this is a POC **ONLY**, there are issues with it, such as memory leaks). |
| | |
| | ==== __toString ==== |
| | |
| | The //toString// magic method would become redundant, since it is just a limited version of the //castTo// handler (it actually implements the cast_object handler internally). Based on that, any class implementing //castTo// would then ignore a //toString// method if it's defined. For backwards compatibility reasons, if //castTo// is **not** defined on the class (or parent), then //toString// would be executed for any string casts. |
| | |
| | Eventually, //toString// would be deprecated as duplicate functionality (but not any time soon, as it would still work fine). |
| |
| ==== Example ==== | ==== Example ==== |
| if (is_numeric($value)) { | if (is_numeric($value)) { |
| $this->value = (int) $value; | $this->value = (int) $value; |
| | return; |
| } | } |
| return false; | return false; |
| * https://wiki.php.net/internals/engine/objects#cast_object | * https://wiki.php.net/internals/engine/objects#cast_object |
| |
| ===== References ===== | ===== Questions ===== |
| |
| * [1] https://secure.wikimedia.org/wikipedia/en/wiki/Weak_reference | |
| * [2] https://secure.wikimedia.org/wikipedia/en/wiki/Observer_pattern | |
| * [3] http://download.oracle.com/javase/1.4.2/docs/api/java/lang/ref/WeakReference.html | |