Zend FR

Bonjour à tous

ceux qui me connaissent bien savent que j'utilise beaucoup les designs patterns et que je préconise leur usage.

il en est un qui est implémenté directement dans php il s'agit de KVC
Key Value Coding
le principe de KVC est de déclarer les membres d'une classe private ou protected
et d'utiliser tout de même les lectures et affectation directe. ces lectures ou affectations appelants automatiquement les méthodes get et set correspondante.

class Toto {
  protected $attr;

  pubic function setAttr($value){
     ...
  }

  public function getAttr(){
    ...
  }
}
$obj = new Toto();
$obj->attr = "test";
echo $obj->attr;

cette approche facilite le travail mais devoir écrire tout les accesseurs est un calvaire. php offre pour cela les méthodes __set et __get mais aussi __isset et __unset

voici un exemple simplifié

  class Object {
    
    public function __set($key, $value){
      $this->$key = $value;
      $this->trace ('set', $key);
    }
    
    public function __get($key){
      if (property_exists($this,$key)){
        $this->trace ('get', $key);
        return $this->$key;
      }
    }
    
    public function trace ($msg, $key){
      echo '<pre>' . $msg . ' ' . $key . ' : ';
      print_r($this);
      echo '</pre>';
    }
    
  }
  
  class myClasse
  extends  Object{
    protected $test;
    
  }

  $obj = new myClasse();
  $obj->test = 45;
  echo $obj->test;

j'ai volontairement ajouté la méthode trace pour qu'on puisse voir le fonctionnement.
on vois rapidement que si on implémente ces méthodes dans une classe de base on en bénéficie partout. bien sur ce n'est qu'un exemple et il faudrait les améliorer en levant une exception lorsque on tente de lire une clef inexistante.
une classe fille peut redéfinir une méthode pour la spécialiser par exemple.

on peut ainsi définir des classes qui acceptent qu'on ajoute dynamiquement des membres et d'autres non.

bref ZF utilise en partie cette façon de faire. et il peut être très pratique de suivre l'exemple.

mais le design patern KVC vas beaucoup plus loin
et je pense qu'une implémentation au coeur de ZF le rendrait beaucoup plus souple.

la théorie définie une approche pour les membres qui sont des collections. mais là ni php ni ZF la suivent.
pourtant il est possible de l'implémenter.

la problématique concerne donc des membres représentants des liste d'éléments. KVC préconise de définir une convention d'accès aux éléments de ces collection.
par exemples prenons un album celui-ci à des membres comme le titre, la pochette, le compositeur, l'interprète etc. mais aussi la liste des pistes
KCV propose de définir une convention comme counOfPistes pour conter les pistes, getItemOfPistesAtIndex getItemOfPistesForKey addItemOfPiste removeItemFromPistes etc.
la construction consiste donc  définir des mots clefs qui associés au nom du membre va définir un accesseur.

là encore si on l'implémente dans une classe de base on en bénéficie partout.

là encore je vous donne une implémentation basique pour illustrer le principe. il conviendrait de vérifier le type du membre gérer des exceptions et les méthodes d'accès propre à certaines classes. (itérateurs par exemple)
KVC prévoit de plus si les type des éléments le permettent l'ajout d'acccesseurs comme sumOf avgOf etc.

encore un fois php nous permets l'implémentation cette fois avec __call
on va prendre la méthode vérifier qu'elle corresponds à un des accesseurs de notre convention et si c'est le cas récupérer la clef du membre et invoquer la méthode adéquate.
le tout pouvant évidement être surcharger par une classe héritière soit de façon globale en redéfinissant __call soit en redéfinissant une des méthodes.

<?php
  class Object {
    
    public function __set($key, $value){
      $this->$key = $value;
      $this->trace ('set', $key);
    }
    
    public function __get($key){
      if (property_exists($this,$key)){
        $this->trace ('get', $key);
        return $this->$key;
      }
    }
    
    
    public function __call($method, $arguments){    
      if (preg_match('/getItemOf([A-Z][a-z]+)AtIndex/', $method, $matches)){
        $this->trace($method, $arguments[0]);
        return $this->getItemOfAtIndex(strtolower($matches[1]),$arguments[0]);
      }
      
      if (preg_match('/countOf([A-Z][a-z]+)/', $method, $matches)){
        $this->trace($method, null);
        return $this->contOf(strtolower($matches[1]));
      }
    }
    
    
    protected function getItemOfAtIndex($key, $index) {
      $collection = $this->__get($key);
      return $collection[$index];
    }
    
    protected function contOf($key) {
      $collection = $this->__get($key);
      return count($collection);
    }
    
    public function trace ($msg, $key){
      echo '<pre>' . $msg . ' ' . $key . ' : ';
      print_r($this);
      echo '</pre>';
    }
    
  }
  
  class myCollection
  extends  Object{
    protected $elements;
    
    public function __construct(){
      $this->elements = array(5, 6, 7, 8);
    }
  }

  $liste = new myCollection();
  echo $liste->countOfElements();
  echo $liste->getItemOfElementsAtIndex(2);

cette façon de faire apporte beaucoup de souplesse mais dans un outil comme ZF il serait intéressant que cela soit intégré dans le FramWork

la convention et les méthodes correspondantes étants dans le FramWork on aurait beaucoup moins de code à écrire

  class myCollection
  extends  Object{
    protected $elements;
    
    public function __construct(){
      $this->elements = array(5, 6, 7, 8);
    }
  }

  $liste = new myCollection();
  echo $liste->countOfElements();
  echo $liste->getItemOfElementsAtIndex(2);

Voilà un petit tour dans le monde KVC.

j'ouvre le débat
Pensez-vus qu'il faille proposer l'intégration complète de KVC dans ZF (3.0) ?
A+JYT