Poo - object class

Soyez le premier à donner votre avis sur cette source.

Snippet vu 4 095 fois - Téléchargée 16 fois

Contenu du snippet

Une classe "racine" permettant d'éviter des erreurs fatales et facilitant le débogue, il suffit de l'étendre pour profiter de ces fonctionnalités.

Source / Exemple :


<?php
/**

  • Class Object is the root of the class hierarchy.
*
  • Every class has Object as a superclass and implements following features:
  • - Adds the ability to reverse-engineer classes, interfaces, functions,
  • methods and extensions of the object using PHP reflection API;
  • - Generates an unique identifier of an object that can be used as a hash key
  • for storing objects or for identifying an object;
  • - Prints a representation of the object when it is converted to a string;
  • - Avoids fatal errors (throws LogicException or BadMethodCallException
  • instead) when:
  • - writing or reading data from inaccessible properties;
  • - calling isset(), empty() or unset() on inaccessible properties;
  • - calling an object as a function;
  • - calling inaccessible methods in an object or static context.
* abstract class Object { /**
  • Returns an instance of ReflectionObject.
*
  • The ReflectionObject class is a part of the PHP Reflection API that adds
  • the ability to reverse-engineer classes, interfaces, functions, methods
  • and extensions of an object.
* *
  • @param void
  • @return ReflectionObject Returns an instance of ReflectionObject.
  • /
final public function getReflection() { static $reflection = null; return $reflection ?: $reflection = new ReflectionObject($this); } /**
  • Returns an unique identifier of the object.
*
  • This identifier is unique for each object and is always the same for the
  • same object. It can be used as a key for storing objects or for
  • identifying an object.
* *
  • @param void
  • @return string Returns an unique identifier of the object.
  • /
final public function getHashCode() { return spl_object_hash($this); } /**
  • Prints a representation of the object when it is converted to a string.
*
  • The string consisting of the name of the class of which the object is an
  • instance, the at-sign character `@`, and the unique identifier for the
  • object.
*
  • @param void
  • @return string Returns a string representation of the object.
  • /
public function __toString() { return $this->getReflection()->getName() . '@' . $this->getHashCode(); } /**
  • Throws an LogicException when writing data to inaccessible properties.
*
  • @param string $propertyName The name of the property being set.
  • @param mixed $propertyValue The value for the property.
  • @return void
  • @throws LogicException If one tries to write data to inaccessible
  • properties.
  • /
public function __set($propertyName, $propertyValue) { $className = $this->getReflection()->getName(); throw new LogicException("Write data to inaccessible property `{$className}::{$propertyName}`."); } /**
  • Throws an LogicException when reading data from inaccessible properties.
*
  • @param string $propertyName The name of the property to retrieve.
  • @return void
  • @throws LogicException If one tries to read data from inaccessible
  • properties.
  • /
public function __get($propertyName) { $className = $this->getReflection()->getName(); throw new LogicException("Read data from inaccessible property `{$className}::{$propertyName}`."); } /**
  • Throws an LogicException when calling isset() or empty() on inaccessible
  • properties.
*
  • @param string $propertyName The name of the property to be checked.
  • @return void
  • @throws LogicException If one tries to apply isset() or empty() on
  • inaccessible property.
  • /
public function __isset($propertyName) { $className = $this->getReflection()->getName(); throw new LogicException("Apply isset() or empty() on inaccessible property `{$className}::{$propertyName}`."); } /**
  • Throws an LogicException when calling unset() on inaccessible properties.
*
  • @param string $propertyName The name of the property to be unset.
  • @return void
  • @throws LogicException If one tries to apply unset() on inaccessible
  • property.
  • /
public function __unset($propertyName) { $className = $this->getReflection()->getName(); throw new LogicException("Apply unset() on inaccessible property `{$className}::{$propertyName}`."); } /**
  • Avoids a fatal error when calling an object as a function, throwing a
  • LogicException instead.
*
  • @param void
  • @return void
  • @throws LogicException If one tries to call an object as a function.
  • /
public function __invoke() { $className = $this->getReflection()->getName(); throw new LogicException("Call object `{$className}` as a function."); } /**
  • Avoids a fatal error when calling inaccessible methods in an object
  • context, throwing a BadMethodCallException instead.
*
  • @param string $methodName The name of the method being called.
  • @param array $arguments Optional, an enumerated array containing the
  • arguments passed to the method.
  • @return void
  • @throws BadMethodCallException If one tries to call inaccessible methods
  • in an object context.
  • /
public function __call($methodName, array $arguments = null) { $className = $this->getReflection()->getName(); throw new BadMethodCallException("Call to inaccessible method `{$className}::{$methodName}()`."); } /**
  • Avoids a fatal error when calling inaccessible methods in a static
  • context, throwing a BadMethodCallException instead.
*
  • @param string $methodName The name of the method being called.
  • @param array $arguments Optional, an enumerated array containing the
  • arguments passed to the method.
  • @return void
  • @throws BadMethodCallException If one tries to call inaccessible methods
  • in a static context.
  • /
static public function __callStatic($methodName, array $arguments = null) { $className = get_called_class(); throw new BadMethodCallException("Call to inaccessible static method `{$className}::{$methodName}()`."); } } // Example class Foo extends Object { const CONST_VALUE = 'A constant value'; private $_var = null; public function bar() { echo 'Hello World !'; } } try { $foo = new Foo(); // pritns: Array ( [CONST_VALUE] => A constant value ) // print_r($foo->getReflection()->getConstants()); // prints: 0000000050ce9726000000002e61f3e9 // echo $foo->getHashCode(); // prints: Foo@0000000050ce9726000000002e61f3e9 // echo $foo; // prints (LogicException): Write data to inaccessible property `Foo::_var`. // $foo->_var = 'Some value'; // prints (LogicException): Call object `Foo` as a function. // $foo('Hello World !'); // prints (BadMethodCallException): Call to inaccessible method `Foo::method(). // $foo->method(); // prints (BadMethodCallException): Call to inaccessible static method // `Foo::method()`. // $foo::method(); // prints: Hello World ! // $foo->bar(); } catch (Exception $exception) { echo $exception->getMessage() . PHP_EOL; } ?>

A voir également

Ajouter un commentaire

Commentaires

Waredan
Messages postés
22
Date d'inscription
vendredi 8 janvier 2010
Statut
Membre
Dernière intervention
19 février 2010

Merci pour ton commentaire, toutes ces sources proviennent d'un projet personnel de mini framework MVC, non pas pour réinventer la roue mais pour ma satisfaction personnelle. Sauf qu'étant un clone de Monk, je peux pas continuer si le code ne me semble pas "beau", alors je les poste ici, d'une part, pour en faire profiter la communauté PHP, d'autre part, ça me semble être une bonne idée pour recevoir des critiques et les améliorer.
neigedhiver
Messages postés
2483
Date d'inscription
jeudi 30 novembre 2006
Statut
Membre
Dernière intervention
14 janvier 2011
15
C'est intéressant. En fait, toutes tes classes postées depuis 2 jours sont intéressantes.
J'aurais peut-être stocké le nom de la classe dans une variable statique dans une méthode name(), un peu comme pour getReflection(), mais comme, justement, l'objet réflexion est "mis en cache" de cette manière, ça doit se jouer à quelques millionnièmes de poil de cul en terme de perfs...

Non non, vraiment, ça fait plaisir de voir des sources toutes simples mais très très propres, intéressantes, 100% POO... Ca change... N'est-ce pas Kohntark ?

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.