Type-Safe Objects in PHP

Welcome! Type-Safe Objects in PHP Sebastian Bergmann http://sebastian-bergmann.de/ May 23 rd 2008

Welcome! Type-Safe Properties in PHP Sebastian Bergmann http://sebastian-bergmann.de/ May 23 rd 2008

Welcome! Of Type Safety, Properties, Annotations, Multiple Inheritance, and Traits Sebastian Bergmann http://sebastian-bergmann.de/ May 23 rd 2008

Who I am
Sebastian Bergmann
Involved in the PHP Project since 2000
Developer of PHPUnit
Author, Consultant, Coach, Trainer

Outline
What is type safety?
Static Typing vs. Dynamic Typing
Strong Typing vs. Weak Typing
Spoiler: PHP is not type-safe
But Java is not really type-safe, either :-) *
* http://www.cis.upenn.edu/~bcpierce/courses/629/papers/Saraswat-javabug.html

Outline
Look at situations where type-safe properties for objects in PHP make sense

Outline
Look at situations where type-safe properties for objects in PHP make sense
Implementing type-safe properties using
Annotations and
__get() and __set()

Type Safety
“A language is type-safe if the only operations that can be performed on data in the language are those sanctioned by the type of the data.”
Definition by Vijay Saraswat

Type Safety
Static Typing
Enforcement of Type Safety at Compile-Time
Type associated with variable name upon declaration
Example Languages: C, C++, C#, Java

Type Safety
Static Typing
Enforcement of Type Safety at Compile-Time
Type associated with variable name upon declaration
Example Languages: C, C++, C#, Java
Dynamic Typing
Enforcement of Type Safety at Runtime
Type associated with value upon creation
Example Languages: Lisp, PHP, Python, Smalltalk

Type Safety
Strong Typing
Restrictions on the intermixing of types that is permitted to occur
Explicit casting from one type to another
Example Languages: C++, C#, Lisp, Java, Python

Type Safety
Strong Typing
Restrictions on the intermixing of types that is permitted to occur
Explicit casting from one type to another
Example Languages: C++, C#, Lisp, Java, Python
Weak Typing
“Not Strong Typing”
Implicit casting from one type to another, for instance
Example Languages: C, JavaScript, PHP

Type Safety in PHP <?php $variable = 'sebastian' ; Dynamic Typing

Type Safety in PHP <?php $variable = 'sebastian'; $variable = 2204 ; Dynamic Typing

Type Safety in PHP <?php $variable = 'sebastian'; $variable = 2204; $variable = array(); Dynamic Typing

Type Safety in PHP <?php $variable = 'sebastian'; $variable = 2204; $variable = array(); $variable = new StdClass ; // ... Dynamic Typing

Type Safety in PHP Weak Typing: Implicit Type Conversion <?php var_dump ( 1 + 1 ); int(2)

Type Safety in PHP Weak Typing: Implicit Type Conversion <?php var_dump( 1 + 1 ); var_dump ( '1' + '1' ); int(2) int(2)

Type Safety in PHP Weak Typing: Implicit Type Conversion <?php var_dump( 1 + 1 ); var_dump('1' + '1'); class One { public function __toString () { return '1' ; } } var_dump (new One + new One ); int(2) int(2) Notice: Object of class One could not be converted to int in /tmp/test.php on line 11 Notice: Object of class One could not be converted to int in /tmp/test.php on line 11 int(2)

Type Safety in PHP Weak Typing: Implicit Type Conversion <?php var_dump( 1 + 1 ); var_dump('1' + '1'); class Two { public function __toString () { return '2' ; } } var_dump (new Two + new Two ); int(2) int(2) Notice: Object of class One could not be converted to int in /tmp/test.php on line 11 Notice: Object of class One could not be converted to int in /tmp/test.php on line 11 int(2)

Type Safety in PHP Weak Typing: Explicit Type Conversion <?php var_dump( 1 + 1 ); var_dump('1' + '1'); class Two { public function __toString() { return '2'; } } var_dump ((string)new Two + (string)new Two ); int(2) int(2) int(4)

Type Safety in PHP Type Hints <?php class Vector { public function add ( Vector $vector ) { // ... } } $x = new Vector ; $x -> add (new Vector );

Type Safety in PHP Type Hints <?php class Vector { public function add ( $vector ) { if (!( $vector instanceof Vector )) { die( 'Argument must be a Vector object.' ); } // ... } } $x = new Vector ; $x -> add (new Vector );

Type Safety in PHP Type Hints <?php class Vector { public function add ( Vector $vector ) { // ... } } $x = new Vector ; $x -> add (new Vector );

Type Safety in PHP Type Hints <?php class Vector { public function add(Vector $vector) { // ... } } $x = new Vector; $x -> add (new StdClass ); Catchable fatal error: Argument 1 passed to Vector::add() must be an instance of Vector, instance of stdClass given, called in /tmp/test.php on line 11 and defined in /tmp/test.php on line 4

Type Safety in PHP Type Hints
PHP 5.3 supports
array and class or interface names as argument type hints
no type hints for return values

Type Safety in PHP Type Hints
PHP 5.3 supports
array and class or interface names as argument type hints
no type hints for return values
Future versions of PHP might support
type hints for scalar types ( string , int , ...)
type hints for return values

Storing Data in Objects <?php class Employee { public $id ; public $name ; }
Attributes publicly accessible
Attributes are also called fields or slots sometimes
No enforcement of value types
Public Attributes

Storing Data in Objects <?php class Employee { protected $id ; protected $name ; public function getId () { return $this -> id ; } public function setId ( $id ) { if ( is_int ( $id )) { $this -> id = $id ; } else { throw new InvalidArgumentException ; } } // ... }
Attributes not directly accessible
Enforcement of value types in setter methods
Protected Attributes and Accessor Methods

Storing Data in Objects <?php class Employee { protected $id ; protected $name ; public function getId () { return $this -> id ; } public function setId ( $id ) { if ( is_int ( $id )) { $this -> id = $id ; } else { // ... } } // ... }
But attributes might still be (unintentionally) accessed directly from “within”

No syntactic relationship between the attribute and the methods that manage it

No syntactic relationship between the attribute and the methods that manage it
These methods have to be called explicitly by the accessing context

Storing Data in Objects Properties
Construct in languages such as C# or Delphi
Just like an attribute, but access is automatically translated into method calls
Use Cases
Type Checking
Bounds Checking
Read-Only Attributes
Persistence
...

Storing Data in Objects Properties
Construct in languages such as C# or Delphi
Just like an attribute, but access is automatically translated into method calls
Use Cases
Type Checking
Bounds Checking
Read-Only Attributes
Persistence
...
Can be implemented in PHP using the __get() , __set() , and __isset() interceptors
This is an idiom used in the eZ Components

Interlude eZ Components
Provide a solid platform for PHP application development
Clean and simple API
Excellent documentation
Keep backward compatibility for longer periods of time
Stable and few regressions
Clean IP, Open Source friendly
http://ezcomponents.org/

Properties The eZ Components Way <?php class Employee { protected $properties = array( 'id' => NULL , 'name' => NULL ); public function __get ( $name ) { switch ( $name ) { case 'id' : case 'name' : { return $this -> properties [ $name ]; } } throw new ezcBasePropertyNotFoundException ( $name ); } // ... }

Properties The eZ Components Way <?php class Employee { public function __set ( $name , $value ) { switch ( $name ) { case 'id' : { if ( is_int ( $value )) { $this -> properties [ $name ] = $value ; } } break; // ... } throw new ezcBasePropertyNotFoundException ( $name ); } // ... }

Properties The eZ Components Way <?php class Employee { // ... public function __isset ( $name ) { switch ( $name ) { case 'id' : case 'name' : { return TRUE ; } } return FALSE ; } }

Type-Safe Properties <?php class Employee { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; }
By now we are used to annotate attribute declarations with type information
This metadata is used, for instance, by PHPDocumentor to generate API documentation
Annotations

But it is also usefull when we want to automatically generate SQL queries or WSDL from an object
Annotations

But it is also usefull when we want to automatically generate SQL queries or WSDL from an object
PHP allows read access to these docblocks at runtime through its Reflection API
So let us use this metadata for reusable __get() and __set() implementations
Annotations

Interlude <?php class Employee { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $class = new ReflectionClass ( 'Employee' ); $attributes = $class -> getProperties (); foreach ( $attributes as $attribute ) { $docComment = $attribute -> getDocComment (); if ( preg_match ( '/@var[s]+([.w]+)/' , $docComment , $matches )) { var_dump ( $matches [ 1 ]); } } Annotations and the Reflection API

Type-Safe Properties <?php abstract class TypeSafeObject { protected $annotationsParsed = FALSE ; protected $properties = array(); protected function parseAnnotations () { if (! $this -> annotationsParsed ) { $class = new ReflectionClass ( $this ); $attributes = $class -> getProperties (); foreach ( $attributes as $attribute ) { $docComment = $attribute -> getDocComment (); if ( preg_match ( '/@var[s]+([.w]+)/' , $docComment , $matches )) { $this -> properties [ $attribute -> getName ()] = array( 'type' => $matches [ 1 ], 'value' => NULL ); } } $this -> annotationsParsed = TRUE ; } } // ... The TypeSafeObject Class

Type-Safe Properties public function __get ( $name ) { $this -> parseAnnotations (); if ( isset ( $this -> properties [ $name ])) { return $this-> properties [ $name ][ 'value' ]; } else { // ... } } The TypeSafeObject Class

Type-Safe Properties public function __get($name) { $this->parseAnnotations(); if (isset($this->properties[$name])) { return $this->properties[$name]['value']; } else { // ... } } public function __set ( $name , $value ) { $this -> parseAnnotations (); if ( isset ( $this -> properties [ $name ]) ) { if ( gettype ( $value ) == $this -> properties [ $name ][ 'type' ]) { $this -> properties [ $name ][ 'value' ] = $value ; } else { // ... } } else { // ... } } // ... The TypeSafeObject Class

Type-Safe Properties public function __isset ( $name ) { $this -> parseAnnotations (); return isset ( $this -> properties [ $name ]); } } The TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; } Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee ; var_dump ( $e -> id ); NULL Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee; $e -> id = '123' ; var_dump ( $e -> id ); NULL Using the TypeSafeObject Class

Type-Safe Properties <?php class Employee extends TypeSafeObject { /** * @var integer */ protected $id; /** * @var string */ protected $name; } $e = new Employee; $e -> id = 123 ; var_dump ( $e -> id ); int(123) Using the TypeSafeObject Class

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Employee extends TypeSafeObject { /** * @var integer */ protected $id ; /** * @var string */ protected $name ; } Problems with the TypeSafeObject Class
Conceptual problem
Employee is a TypeSafeObject

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Person extends TypeSafeObject { // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Problems with the TypeSafeObject Class
Conceptual problem
This usually does not fit into our model

Type-Safe Properties <?php abstract class TypeSafeObject { // ... } class Person extends TypeSafeObject { // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Problems with the TypeSafeObject Class
Conceptual problem
PHP 5.3 supports
Single Implementation Inheritance
Multiple Interface Inheritance

Type-Safe Properties <?php trait TypeSafeObject { // ... } class Person { use TypeSafeObject ; // ... } class Employee extends Person { /** * @var integer */ protected $id; /** * @var string */ protected $name; } Traits to the rescue!
Conceptual problem
PHP 5.3 supports
Single Implementation Inheritance
Multiple Interface Inheritance
Future versions of PHP will support Traits
Safe variant of multiple implementation inheritance
A class can implement multiple interfaces
A class can extend a single class
A class can use multiple traits
Reuse sets of methods freely in several independent classes living in different class hierarchies

Inheritance
Single Inheritance
A class can inherit interface and implementation from a single parent class

Inheritance
Single Inheritance
Interfaces

Inheritance
Single Inheritance
Interfaces
Multiple Inheritance
A class can inherit interface and implementation from multiple parent classes

A class has contradicting goals
Generator of Instances
Must be complete
Must have a unique place in the class hierarchy
Unit of Reuse
Should be small
Should be applicable at arbitrary places
Problems

A class has contradicting goals
Generator of Instances
Must be complete
Must have a unique place in the class hierarchy
Unit of Reuse
Should be small
Should be applicable at arbitrary places
“Multiple inheritance is good, but there is no good way to do it.” (Steve Cook)
Example: The Diamond Problem
Problems

Multiple Inheritance The Diamond Problem class A { public function method () { } }
Class A declares method()

Multiple Inheritance The Diamond Problem class A { public function method() { } } class B extends A { public function method () { } } class C extends A { public function method () { } }
Classes B and C inherit from A and override method() differently

Multiple Inheritance The Diamond Problem class A { public function method() { } } class B extends A { public function method() { } } class C extends A { public function method() { } } class D extends B , C { }
Class D inherits from both B and C and does not override method()

Multiple Inheritance The Diamond Problem class A { public function method() { } } class B extends A { public function method() { } } class C extends A { public function method() { } } class D extends B, C { } $d = new D ; $d -> method ();
Class D inherits from both B and C and does not override method()
When we call method() on an object of D , which implementation should be called?

Traits
New unit of reuse
Provide structure, modularity and reusability within classes
Can be incomplete

Traits
New unit of reuse
Can be incomplete
Less complex than Multiple Inheritance
The typical problems associated with multiple inheritance (as well as mixins) are avoided

Traits
New unit of reuse
Can be incomplete
Less complex than Multiple Inheritance
The typical problems associated with multiple inheritance (as well as mixins) are avoided
Flattening Property
Traits are flattened into classes at compile-time
No notion of traits at runtime

Resources
Libraries
https://labs.omniti.com/trac/alexandria/browser/trunk/OmniTI/Object.php
Annotation-based, Type-Safe Properties
Support for Mix-In Inheritance
http://jan.kneschke.de/projects/typesafe-objects-in-php
Annotation-based, Type-Safe Properties
Automatic generation of SQL and WSDL
http://instantsvc.sourceforge.net/
Extended Reflection API
Automatic generation of WSDL
Traits
http://wiki.php.net/rfc/traits
Background Information
Specification and Patch for implementation in C for PHP

The End
Thank you for your interest!
These slides will be available shortly on http://sebastian-bergmann.de/talks/.

License
This presentation material is published under the Attribution-Share Alike 3.0 Unported license.
You are free:
to Share – to copy, distribute and transmit the work.
to Remix – to adapt the work.
Under the following conditions:
Attribution. You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of the work).
Share Alike. If you alter, transform, or build upon this work, you may distribute the resulting work only under the same, similar or a compatible license.
For any reuse or distribution, you must make clear to others the license terms of this work.
Any of the above conditions can be waived if you get permission from the copyright holder.
Nothing in this license impairs or restricts the author's moral rights.

http://sebastian-bergmann.de	846
http://www.planet-php.net	138
http://krsteski.de	104
http://www.slideshare.net	60
http://www.planet-php.org	34
http://planet-php.org	16
http://www.phpeye.com	11
http://lj-toys.com	6
http://www.activars.com	4
http://www.xianguo.com	2
http://www.techgig.com	2
http://webcache.googleusercontent.com	1
http://planet-php.net	1
file://	1
http://www.xaprb.com	1
applewebdata://848ED1FE-2DF6-403A-AA8D-C5555B9621A8	1
http://www.theinquirer.de	1
http://livebuzz.com.br	1

Type-Safe Objects in PHP

by Sebastian Bergmann on May 23, 2008

Accessibility

Categories

Tags

Upload Details

Usage Rights

18 Embeds 1,230

Statistics

Type-Safe Objects in PHP — Presentation Transcript