Self hydrating object proxy in PHP Provides faster hydration by removing the need for reflection.

README.md

This piece of code tries to reduce the performance overhead needed to populate an object's properties via reflection.

An example of its usage can be found at http://3v4l.org/he2dF

Foo.php

<?php

class Foo
{
    protected $foo;
    protected $bar;
    protected $baz;
}

FooSelfHydratingProxy.php

<?php

class FooSelfHydratingProxy extends Foo implements HydratorInterface
{
    /** zero-argument constructor since this is just a helper class for hydration */
    public function __construct()
    {
    }
    
    /**
     * the `Foo` typehint is not part of the interface - here only for the sake of readability/clearness
     */
    public function hydrate($data, Foo $object)
    {
        $object->foo = $data['foo'];
        $object->bar = $data['bar'];
        $object->baz = $data['baz'];
    }

    /**
     * the `Foo` typehint is not part of the interface - here only for the sake of readability/clearness
     */
    public function extract(Foo $object)
    {
        return array('foo' => $object->foo, 'bar' => $object->bar, 'baz' => $object->baz);
    }
}

hydrator-performance.php

<?php

$iterations = 100000;

class A {protected $a; protected $b; protected $c;}
class AHydrator extends A {
    public function hydrate(A $a, array $data)
    {
        $a->a = $data['a'];
        $a->b = $data['b'];
        $a->c = $data['c'];
    }
}

$data = array('a' => 1, 'b' => 2, 'c' => 3);
$a = new A();
$h = new AHydrator();

for ($i = 0; $i < $iterations; $i++) {
    $h->hydrate($a, $data);
}

reflection-performance.php

<?php

$iterations = 100000;

class A {protected $a; protected $b; protected $c;}

$rA = new ReflectionProperty('A', 'a');
$rB = new ReflectionProperty('A', 'b');
$rC = new ReflectionProperty('A', 'c');

$rA->setAccessible(true);
$rB->setAccessible(true);
$rC->setAccessible(true);

$data = array('a' => 1, 'b' => 2, 'c' => 3);
$a = new A();

for ($i = 0; $i < $iterations; $i++) {
    $rA->setValue($a, $data['a']);
    $rB->setValue($a, $data['b']);
    $rC->setValue($a, $data['c']);
}

This is brilliant @Ocramius! I was looking for a way to hydrate my entities without using slow Reflection or adding setters unnecessarily.

@prograhammer this is just meant for D2 internals, not for the "general public"

@Ocramius it's a valid strategy perhaps though, for projects that can't use the D2 ORM ...

@Ocramius so if this change will happen in D2 all entities should be refactored to have protected properties instead of private? Also extending entity can have some drawbacks... Please, look at this example . It also has nice performance and can be used to set private properties.

Why does HydratorA extend A? It's confusing without doing anything. Also the questino is not answered: Why was the reflection there in the first place? Probably because of unknown properties..

@flowl that's an old concept that I used in a library called GeneratedHydrator: https://github.com/Ocramius/GeneratedHydrator

The idea is that by using inheritance, you can avoid property access hooks that are used by PHP to determine whether you can access a field or not.

The idea is that by using inheritance, you can avoid property access hooks that are used by PHP to determine whether you can access a field or not.

Ahh you are right, I remember... extending a class gives the current one permission to access non-public properties.
I just downloaded GeneratedHydrator to try it out :-)