Question

i was wanting to wrap an object in another – favoring composition over inheritance. but i am not sure i am doing it right tho there are no errors.

i created a class Wrapped thats is wrapped by Wrapper. i made it such that when a method/property is called on $wrapper, if it exists in the class, Wrapper, it will be returned else, it will delegate to the $wrapped object. i wonder apart from the fact i didnt check if the method/property exists, what have i done wrong? can some1 explain __callStatic() too?

class Wrapped {
    protected $wrappedProp1 = 'Wrapped: Property 1';
    protected $wrappedProp2 = 'Wrapped: Property 2';

    function method1($arg1, $arg2) {
        echo "Called Wrapped::method1() with the following parameters: $arg1, $arg2";
    }

    static function sMethod2() {
        echo 'Called a static method in wrapped';
    }

    function __get($name) {
        return $this->$name;
    }
    function __set($name, $val) {
        $this->$name = $val;
    }
}
class Wrapper {
    protected $wrapperProp1 = 'Wrapper: Property 1';
    protected $wrapped;

    function __construct($wrapped) {
        $this->wrapped = $wrapped;
    }

    function wrapperMethod() {
        echo 'In wrapper method';
    }

    function __get($name) {
        if (property_exists($this, $name)) {
            return $this->$name;
        }
        return $this->wrapped->$name;
    }
    function __set($name, $val) {
        if (property_exists($this, $name)) {
            $this->$name = $val;
        }
        $this->wrapped->$name = $val;
    }
    function __call($name, $args = array()) {
        call_user_func_array(array($this->wrapped, $name), $args);
    }
    static function __callStatic($name, $args = array()) {
        call_user_func_array(array('Wrapped', $name), $args);
    }
}

$wrapper = new Wrapper(new Wrapped);

// testing normal methods
$wrapper->wrapperMethod();
echo $wrapper->wrapperProp1;
$wrapper->wrapperProp1 = 'New Wrapper Prop 1';
echo $wrapper->wrapperProp1;

// testing delegates
$wrapper->method1('hello', 'world'); //delegated to Wrapped::method1()
$wrapper->sMethod2(); // delegated to static Wrapped::sMethod2() ... what is callStatic for then
echo $wrapper->wrappedProp2;
Wrapper::sMethod2();

Answer 1

As it seems – it’s all ok.

About __callStatic() – it allows you to workaround undefined static functions in class.
Example:

<?php
class Foo {
    static function __callStatic($name, $args = array()) {
        echo "Called static function $name with arguments ". print_r($args, true);
    }
}

Foo::Bar('test');
// will output "Called static function Bar with arguments Array ( 0 => test );"