<?php
class Agregateur extends Agregator
{
    protected $foo;
    protected $bar;
    public $anaska;
}

class Foo { }
class Bar { }

$agregateur = new Agregateur();

$agregateur->setFoo(new Foo); // OK
$agregateur->setBar(new Bar); // OK
$agregateur->setAnaska(new Bar); // KO : $anaska est publique
$agregateur->setAnything(new AnyThing) // KO : la propriété (et la classe) Anything n'existe pas
$agregateur->setBar('hello world') // KO 'hello world' n'est pas une instance de Bar.

<?php
foreach ($agregateur as $objetagrege) {
    var_dump($objetagrege);
}
/* doit afficher quelque chose du style :
object(Foo)#2 (0) { } 
object(Bar)#4 (0) { }
object(Bar)#5 (0) { }
tous nos objets agrégés, quels qu'ils soient
*/

<?php
abstract class Agregator
{
    private $props = array();
    
    final private function __call($fun,$args) // méthode "set{Paramètre}"
    {
        if (substr($fun, 0, 3) == "set" && // si la méthode commence par "set"
            array_key_exists(0,$args) // et qu'elle possède au moins un argument
            ) {
                $class = new ReflectionClass($this);
                try {   // le paramètre existe-t-il dans cette classe?
                    $param = new ReflectionProperty($this,$paramName = strtolower(substr($fun,3)));
                }catch(ReflectionException $e) { // non ? gardons le comportement de PHP : pas d'exceptions
                    trigger_error("Call to undefined method ".get_class($this)."::$fun()",E_USER_ERROR); // erreur : la méthode  "set{Paramètre}" n'existe pas
                }
                if (!$param->isPublic() && // le paramètre est-il non public ?
                    $args[0] instanceof $paramName) { // l'argument passé en est-il une instance ?
                        if (!is_array($this->$paramName)) {
                           $this->$paramName = array(); // quelque soit le type du paramètre, c'est un tableau forcé
                        }
                        array_push($this->$paramName,$args[0]); // auquel on rajoute l'argument "objet"
                        if(!in_array($paramName,$this->props)) {
                            $this->props[] = $paramName; // nous le mémorisons pour l'itérer plus tard
                        }
                }
       }else{
           trigger_error("Call to undefined method ".get_class($this)."::$fun()",E_USER_ERROR);
       }
       return $this;
   }
}

<?php
abstract class Agregator implements Iteratoragregate
{
   // ... suite de la classe précédente ...
   final public function getIterator()
   {
       $array = array();
       $self = new ReflectionObject($this);
       foreach ($self->getProperties() AS $property) {
           $array[] = $property->getName();
       }
       $props = array_intersect($this->props,$array);
       $array = array();
       foreach ($props as $prop) {
            $array[] = $this->$prop;
       }
       return new RecursiveIteratorIterator(new RecursiveArrayIterator($array));
   }

<?php
class Agregateur extends Agregator
{
    protected $foo;
    protected $bar;
    protected $foobar;
}

class Foo { }
class Bar { }
class Foobar { }
$ag = new Agregateur();

$ag->setFoo(new Foo);
$ag->setBar(new Bar);
$ag->setBar(new Bar);
$ag->setFoobar(new Foobar);

foreach ($ag as $object) {
	var_dump($object); 
}
// affiche object(Foo)#1 (0) { }  object(Bar)#2 (0) { } object(Bar)#3 (0) { }  object(Foobar)#4 (0) { }