Peter Olds (2013-04-24 07:49:38)

Not that this is a wise idea but I learned you can use the magic function __callStatic to chain into other classes as demonstrated below:

<?php

class ClassOne {
    public static function functionOne() {
        echo 'classOne::functionOne()';
    }

    public static function __callStatic( $name, $arguments = array() ) {
        ClassTwo::$name( $arguments );
    }
}

class ClassTwo {
    public static function functionTwo() {
        echo 'classTwo::functionTwo()';
    }

    public static function __callStatic( $name, $arguments = array() ) {
        ClassThree::$name( $arguments );
    }
}

class ClassThree
{
    public static function functionThree() {
        echo 'ClassThree::FunctionThree()';
    }
}

ClassOne::functionOne();
ClassOne::functionTwo();
ClassOne::functionThree();

?>

theaceofthespade at gmail dot com (2012-03-23 21:35:55)

A word of warning! It may seem obvious, but remember, when deciding whether to use __get, __set, and __call as a way to access the data in your class (as opposed to hard-coding getters and setters), keep in mind that this will prevent any sort of autocomplete, highlighting, or documentation that your ide mite do.
Furthermore, it beyond personal preference when working with other people. Even without an ide, it can be much easier to go through and look at hardcoded member and method definitions in code, than having to sift through code and piece together the method/member names that are assembled in __get and __set.
If you still decide to use __get and __set for everything in your class, be sure to include detailed comments and documenting, so that the people you are working with (or the people who inherit the code from you at a later date) don't have to waste time interpreting your code just to be able to use it.

_ at apakoh dot dk (2012-02-16 16:11:48)

I find the following use of __set and __get useful:

<?php
class Post {
  private $title;
  private $content;
  private $author;
  private $comments;

  private $_getters = array('title', 'content', 'author', 'comments');
  private $_setters = array('title', 'content', 'author');
  
  public function __get($property) {
    if (in_array($property, $this->_setters)) {
      return $this->$property;
    }
    else if (method_exists($this, '_get_' . $property))
      return call_user_func(array($this, '_get_' . $property));
    else if (in_array($property, $this->_getters) OR method_exists($this, '_set_' . $property))
      throw new Exception('Property "' . $property . '" is write-only.');
    else
      throw new Exception('Property "' . $property . '" is not accessible.');
  }

  public function __set($property, $value) {
    if (in_array($property, $this->_getters)) {
      $this->$property = $value;
    }
    else if (method_exists($this, '_set_' . $property))
      call_user_func(array($this, '_set_' . $property), $value);
    else if (in_array($property, $this->_setters) OR method_exists($this, '_get_' . $property))
      throw new Exception('Property "' . $property . '" is read-only.');
    else
      throw new Exception('Property "' . $property . '" is not accessible.');
  }
}
?>

This way the variables in the $_getters array can be read from the outside and the variables in the $_setters array can be modified from the outside, like this:

<?php
$post = new Post();
$post->title = 'Hello, World';
echo $post->title;

// The following will throw an exception since $comments is read-only:
$post->comments = 23;
?>

And in case you need a less generic getter or setter at some point, you can remove the variable from the $_getters or $_setters array and implement a method like:

<?php
private function _set_title($value) {
  $this->title = str_replace('World', 'Universe', $value);
}
?>

And from the outside the property could still be used with:

<?php
$post->title = 'Hello, World!';
?>

I've tried a couple of different ways of doing this, but this seems to be the fastest (although still around 2 times slower than using ugly old school getter- and setter-methods).
Functions like property_exists() are unnecessary and only makes thing even slower (my initial attempt at using __set and __get was up to 9 times slower than traditional getter/setter methods).

Could probably still be improved/changed in different ways depending on context.

Voitcus at wp dot pl (2011-11-02 12:57:34)

If a class is being extended by another class, its __get and __set methods (and others) can also be overloaded themselves:

<?php
class A {
  public function __get($value){
    switch($value){
      case "a1": return 1; break;
      case "a2": return 2; break;
    default: // error handler goes here
      return "number out of range"; // or NULL or anything else
       }
     } // end of method __get
   } // end of class A

class B extends A {
  public function __get($value){
     switch($value){
       case "a1": return 11; break; // we overload value of 1
       case "b3": return 3; break; // we add these new properties
       case "b4": return 4; break;
     default: // check ancestor's properties
       return parent::__get($value);
       }
     } // end of method __get
   } //end of class B

$a=new A();
$b=new B();

echo $a->a1; // produces 1
echo $a->a2; // produces 2
echo $a->b3; // produces number out of range

echo $b->a1; // produces 11
echo $b->a2; // produces 2
echo $b->b3; // produces 3
echo $b->b4; // produces 4
echo $b->b5; // produces number out of range
?>

If class B's default switch option is reached, the class A's getter is called. So the extending class B overloads property "a1", adds its own properties "b3" and "b4", and inherits property "a2". This solution can't, however, overload class A's error handler (the line with "number out of range").
Should it be needed, consider the following error handler of the class B:

<?php
     default: // error handler goes here
       $p=parent::__get($value);
       if(!is_numeric($p)){
          return "no value"; // overload class A's error message
          }
       else{
           return $p; // return class A's base properties
           }
?>
So we have new "error handler"
<?php
echo $b->b5; // produces no value
?>

ari at asu dot edu (2011-10-31 01:57:59)

It may be important to note that when __set($name, $value) is called, $name gets entered into the symbol table for that call stack. This means that if a property is set within __set, it will only work if that property's name appears in the call stack (ie if it matches $name). If not, __set will be called again on the new property recursively.

<?php
class test
{
    function __set($name, $value)
    {
        echo "__set($name, $value);\n";
        $this->prop3 = $value; // This will call __set(prop3, value)
        $this->prop2 = $value; // This will call __set(prop2, value)
        $this->prop1 = $value; // This will NOT call __set(prop1, value) because $name == prop1.
    }
}

$test = new test;
$test->prop1 = 'value';
?>

It could be thought of like this: within the function __set($name, $value), $this->[property name] = [value] will recurse unless property name == $name. Within the call stack of __set, __set will never recurse on the same name twice. Once you leave __set (without actually creating the property), the call stack ends and all bets are off. 

What this means:
You cannot do things like setting an (uppercase) property to lowercase within __set without expecting __set to be called twice. If you were to add an underscore to the property name, you can expect an infinite recursion loop.

I hope someone finds this useful. It drove me nuts for a few hours.

matt at mcmcms dot com (2011-10-13 05:31:08)

If you need to try and imitate the functionality of the __get() and __set() magic methods whilst outside of the object-scope (i.e. using a static method) this small __callStatic() implementation may help you out.

<?php

class config
{

private static $_propertyArray = array();

        public static function __callStatic( $method, $args )
        {
            $property = $args[0];
            
                switch( $method )
                {
                    case 'set':
                        // set property
                            self::$_propertyArray[ $property ] = $args[1];
                    break;
            
                    case 'get':
                        // get property
                            if( isset( self::$_propertyArray[ $property ] ) )
                            {
                                return self::$_propertyArray[ $property ];
                            }
                            else {
                                throw new Exception( "Property ({$property}) does not exist", 0 );
                            }
                    break;
            
                    default:
                        // do nothing..
                    break;
                }
        }
}

config::set( 'my_property', 'someValue' );

print "The value of 'my_property' is: " . config::get( 'my_property' );

// Will output: The value of 'my_property' is: someValue

?>

dans at dansheps dot com (2011-08-01 08:38:52)

Since this was getting me for a little bit, I figure I better pipe in here...

For nested calls to private/protected variables(probably functions too) what it does is call a __get()  on the first object, and if you return the nested object, it then calls a __get() on the nested object because, well it is protected as well.

EG:
<?php
class A
{
protected $B

public function __construct()
{
$this->B = new B();
}

public function __get($variable)
{
echo "Class A::Variable " . $variable . "\n\r";
$retval = $this->{$variable};
return $retval;
}
}

class B
{
protected $val

public function __construct()
{
$this->val = 1;
}

public function __get($variable)
{
echo "Class B::Variable " . $variable . "\n\r";
$retval = $this->{$variable};
return $retval;
}
}

$A = new A();

echo "Final Value: " . $A->B->val;
?>

That will return something like...

Class A::Variable B
Class B::Variable val
Final Value: 1

It seperates the calls into $A->B and $B->val

Hope this helps someone

jk at jankriedner dot de (2011-06-07 03:15:54)

You should take care when using properties retrieved via __get() in functions that expect arguments to be passed by reference (e.g. mysqli_stmt_bind_param). The reference is NOT set to the property itself, but to the value returned by __get().
Thus, binding a property retrieved via __get() to a statement will let the statement be executed always with the value the property had when calling bind_param, not with the current value it has when calling execute().
E.g.:
<?php
error_reporting(E_ALL);
class foo {
    protected $bar;
    
    public function __construct() {
        $this->bar = "Hello World!";
    }
    public static function factory() {
        return new self;
    }
    public function __get($property) {
        if(!property_exists($this,$property)) {
            throw new InvalidArgumentException("Property {$property} doesn't exist");
        }
        return $this->$property;
    }
    public function setBar($value) {
        $this->bar = $value;
    }
}
$foo = new foo();
echo $foo->bar;    // Ouputs: Hello World!
$db = new mysqli("localhost","root","","tests");
$sql = "INSERT INTO foo SET bar=?";
$res = $db->prepare($sql);
$res->bind_param("s",$foo->bar);  // Notice: Indirect modification of overloaded property foo::$bar has no effect in /var/www/overload.php on line 24
$res->execute();  // Writes "Hello World!" to database
$foo->setBar("Goodbye");
echo $foo->bar;   // Outputs: Goodbye
$res->execute();  // Writes "Hello World!" to database
?>

Daniel Smith (2011-05-23 16:15:46)

Be careful of __call in case you have a protected/private method. Doing this:

<?php
class TestMagicCallMethod {
    public function foo()
    {
        echo __METHOD__.PHP_EOL;
    }

    public function __call($method, $args)
    {
        echo __METHOD__.PHP_EOL;
        if(method_exists($this, $method))
        {
            $this->$method();
        }
    }
    
    protected function bar()
    {
        echo __METHOD__.PHP_EOL;
    }

    private function baz()
    {
        echo __METHOD__.PHP_EOL;
    }
}

$test    =    new TestMagicCallMethod();
$test->foo();
/**
 * Outputs: 
 * TestMagicCallMethod::foo
 */

$test->bar();
/**
 * Outputs: 
 * TestMagicCallMethod::__call
 * TestMagicCallMethod::bar
 */

$test->baz();
/**
 * Outputs:
 * TestMagicCallMethod::__call
 * TestMagicCallMethod::baz
 */
?>

..is probably not what you should be doing. Always make sure that the methods you call in __call are allowed as you probably dont want all the private/protected methods to be accessed by a typo or something.

jan dot machala at email dot cz (2011-04-15 03:47:32)

Example of usage __call() to have implicit getters and setters

<?php
class Entity {
    public function __call($methodName, $args) {
        if (preg_match('~^(set|get)([A-Z])(.*)$~', $methodName, $matches)) {
            $property = strtolower($matches[2]) . $matches[3];
            if (!property_exists($this, $property)) {
                throw new MemberAccessException('Property ' . $property . ' not exists');
            }
            switch($matches[1]) {
                case 'set':
                    $this->checkArguments($args, 1, 1, $methodName);
                    return $this->set($property, $args[0]);
                case 'get':
                    $this->checkArguments($args, 0, 0, $methodName);
                    return $this->get($property);
                case 'default':
                    throw new MemberAccessException('Method ' . $methodName . ' not exists');
            }
        }
    }

    public function get($property) {
        return $this->$property;
    }

    public function set($property, $value) {
        $this->$property = $value;
        return $this;
    }

    protected function checkArguments(array $args, $min, $max, $methodName) {
        $argc = count($args);
        if ($argc < $min || $argc > $max) {
            throw new MemberAccessException('Method ' . $methodName . ' needs minimaly ' . $min . ' and maximaly ' . $max . ' arguments. ' . $argc . ' arguments given.');
        }
    }
}

class MemberAccessException extends Exception{}

class Foo extends Entity {
    protected $a;
}

$foo = new Foo();
$foo->setA('some'); // outputs some
echo $foo->getA();

class Bar extends Entity {
    protected $a;
    /**
     * Custom setter.
     */
    public function setA($a) {
        if (!preg_match('~^[0-9a-z]+$~i', $a)) {
            throw new MemberAccessException('A can be only alphanumerical');
        }
        $this->a = $a;
        return $this;
    }
}

$bar = new Bar();
$bar->setA('abc123'); // ok
$bar->setA('[]/*@...'); // throws exception
?>

dvessel (2011-03-29 17:46:45)

A controlled way to chain the results of a method call onto a new property. I thought it was impossible to do cleanly but I finally found a decent way of handling it.

<?php

class main {
  public function newMember($value) {
    return new sub($this, $value);
  }
}

class sub {
  protected $parent;
  protected $value;

  public function __construct($parent, $value) {
    $this->parent = $parent;
    $this->value  = $value;
  }
  public function __get($name) {
    $this->parent->$name = $this->value;
    return $this;
  }
  public function __call($name, $args) {
    // Invoke parent class.
    return call_user_func_array(array($this->parent, $name), $args);
  }
}

$object = new main();

$object->newMember('value for foo')->foo->newMember('value for bar')->bar;

print var_dump($object->foo);
print var_dump($object->bar);

// prints out "value for foo" and "value for bar".

?>

Without the secondary 'sub' class, the chaining can be unpredictable since it doesn't carry over any state information. This way you can encapsulate the results into the supporting class and let it do the work.

Anonymous (2010-12-19 03:12:34)

Using anon functions, you can allow your class methods to be declared after your class is already set.  Though you cannot use a class property as a function in any way (including for properties that are objects with their own __invoke() method) without triggering a fatal error, there is a workaround using an array property to store all these anon functions...

<?php

class Test {
    // generic class allowing dynamic addition of methods

    public $anon_list = array(); // list of all custom added methods

    function __call($fnc, $args) {return call_user_func_array($this->anon_list[$fnc], $args);}
    
    function __set($name, $val) {$this->anon_list[$name] = $val;}
    
    }

// Example adding a new custom method
$test = new Test;
$test->do_something = function ($var1, $var2) {echo "custom called with $var1 and $var2\n";};
$test->do_something('asdf', 'test');

?>

Unfortunately, without access to $this within the anon functions, it's not really useful.  You can "use ($test)" in your anon function, but that just makes it more complicated.

php at lanar dot com dot au (2010-06-12 17:39:47)

Note that __isset is not called on chained checks. 
If isset( $x->a->b ) is executed where $x is a class with __isset() declared, __isset() is not called.

<?php

class demo
{
    var $id ;
    function __construct( $id = 'who knows' )
    {
        $this->id = $id ;
    }
    function __get( $prop )
    {
        echo "\n", __FILE__, ':', __LINE__, ' ', __METHOD__, '(', $prop, ') instance ', $this->id ;
        return new demo( 'autocreated' ) ; // return a class anyway for the demo
    }
    function __isset( $prop )
    {
        echo "\n", __FILE__, ':', __LINE__, ' ', __METHOD__, '(', $prop, ') instance ', $this->id ;
        return FALSE ;
    }
}
$x = new demo( 'demo' ) ;
echo "\n", 'Calls __isset() on demo as expected when executing isset( $x->a )' ;
$ret = isset( $x->a ) ;
echo "\n", 'Calls __get() on demo without call to __isset()  when executing isset( $x->a->b )' ;
$ret = isset( $x->a->b ) ;
?>

Outputs

Calls __isset() on demo as expected when executing isset( $x->a )
C:\htdocs\test.php:31 demo::__isset(a) instance demo
Calls __get() on demo without call to __isset()  when executing isset( $x->a->b )
C:\htdocs\test.php:26 demo::__get(a) instance demo
C:\htdocs\test.php:31 demo::__isset(b) instance autocreated

navarr at gtaero dot net (2010-05-15 13:25:47)

If you want to make it work more naturally for arrays $obj->variable[] etc you'll need to return __get by reference.

<?php
class Variables
{
        public function __construct()
        {
                if(session_id() === "")
                {
                        session_start();
                }
        }
        public function __set($name,$value)
        {
                $_SESSION["Variables"][$name] = $value;
        }
        public function &__get($name)
        {
                return $_SESSION["Variables"][$name];
        }
        public function __isset($name)
        {
                return isset($_SESSION["Variables"][$name]);
        }
}
?>

~A! (2010-04-27 09:03:22)

Dynamic getting-setting using __call and __callStatic
<?php

   class A {
        private $fields;

        public function __call($func, $args) {
            if (empty($args)) {
                return $this->fields[$args[0]];
            } else {
                $this->$fields[$func] = $args[0];
        }
    }

?>

Or statically:

<?php
    class foo {
        static $vals;
        public static function __callStatic($func, $args) {
            if (!empty($args)) {
                self::$vals[$func] = $args[0];
            } else {
                return self::$vals[$func];
            }
        }
    }
?>

Which would allow you to say:

<?php
    Foo::username('john');
    print Foo::username(); // prints 'john'
?>

zzzzbov (2010-04-26 12:30:06)

I've written a brief, generic function for __get() and __set() that works well implementing accessor and mutator functions.

This allows the programmer to use implicit accessor and mutator methods when working with attribute data.

<?php

class MyClass
{
    private $degrees

    public function __get($name)
    {
        $fn_name = 'get_' . $name;
        if (method_exists($this, $fn_name))
        {
            return $this->$fn_name();
        }
        else
        {
            return null;
        }
    }

    public function __set($name, $value)
    {
        $fn_name = 'set_' . $name;
        if (method_exists($this, $fn_name))
        {
            $this->$fn_name($value);
        }
    }

    private function get_degrees()
    {
        return $this->degrees;
    }
    
    private function set_degrees($value)
    {
        $this->degrees = $value % 360;
        if ($degrees < 0) $this->degrees += 360;
    }
}

?>

f4bi0_ at hotmail dot com (2010-04-01 13:12:21)

TRICKY CHALLENGE: is there a way to check if $object->variable exists without automatically triggering the functionality of __get in case the variable doesn't exist?

TRADITIONAL WAY:
<?php

$object = new someClass(); // imagine someClass uses the Magic Method "__get"

if($object->variable){
 // do something

} else {

 // "__get" has inevitably been triggered :-(

}

?>

Ok, above we have the conventional way to check if a variable exists inside the object, the problem is that sometimes we DON'T WANT TO TRIGGER __GET in case the statement returns false!

ALTERNATIVE WAY:

<?php
if(array_key_exists( 'variable', get_object_vars($object) ) ){

 // do something

} else {

 // "__get" has no idea what is going on, i think it is still asleep :-)

}

?>

you can even turn this into a function or something

strata_ranger at hotmail dot com (2009-10-07 09:56:46)

Combining two things noted previously:

1 - Unsetting an object member removes it from the object completely, subsequent uses of that member will be handled by magic methods.
2 - PHP will not recursively call one magic method from within itself (at least for the same $name).

This means that if an object member has been unset(), it IS possible to re-declare that object member (as public) by creating it within your object's __set() method, like this:

<?php
class Foo
{
  function __set($name, $value)
  {
    // Add a new (public) member to this object.
    // This works because __set() will not recursively call itself.
    $this->$name= $value;
  }
}

$foo = new Foo();

// $foo has zero members at this point
var_dump($foo);

// __set() will be called here
$foo->bar = 'something'; // Calls __set()

// $foo now contains one member
var_dump($foo);

// Won't call __set() because 'bar' is now declared
$foo->bar = 'other thing';

?>

Also be mindful that if you want to break a reference involving an object member without triggering magic functionality, DO NOT unset() the object member directly.  Instead use =& to bind the object member to any convenient null variable.

Franz (2009-10-05 10:59:24)

It says in the documentation that assignment chaining does not work with the __set() function like this:

<?php
$a = $foo->b = 3;
?>

If you still want to make it work, I suppose you can just turn the variables around:

<?php
$foo->b = $a = 3;
?>

kexianbin at diyism dot com (2009-08-21 11:29:17)

By using __call, we can use php as using jQuery:

<?php
//SoWork PHP Framework
define('this', mt_rand());
$o='so_work';
class cls_so_work
      {function __call($fun, $pars)
                {foreach ($pars as &$v)
                         {if ($v===this)
                             {$v=$this->val;
                              break;
                             }
                         }
                 $tmp=eval('return defined("'.$fun.'")?constant("'.$fun.'"):"'.$fun.'";');
                 $this->val=call_user_func_array($tmp, $pars);
                 return $this;
                }
       function cls_so_work($obj)
                {$this->val=isset($obj)?$obj:null;
                }
      }
function so_work($obj)
         {if (isset($obj))
             {return new cls_so_work($obj);
             }
          else
              {if (!isset($GLOABALS['so_work']))
                  {$GLOABALS['so_work']=new cls_so_work();
                  }
               else
                   {$GLOABALS['so_work']->val=null;
                   }
               return $GLOABALS['so_work'];
              }
         }

define('echo', 'my_echo');
function my_echo($obj)
         {echo $obj;
          return $obj;
         }

$o('abcd')->substr(this, 2, 2)->strlen(this)->echo(this);
$o()->substr('abcd', 1, 3)->strlen(this)->echo(this);
?>

eric dot druid+php dot net at gmail dot com (2009-07-01 16:22:49)

I needed to know from where a member variable was set from to determine visibility. 

<?php
class foo {
  private $data;
  public function __set($name, $value) {
    $trace = debug_backtrace();
    if(!isset($trace[1]) || $trace[1]['object'] != $trace[0]['object']) {
      die("Trying to set protected member '$name' from public scope.");
    }
    $data[$name] = $value;
  }
}
?>

Anonymous (2009-06-05 15:54:02)

It is possible to accomplish method polymorphism via PHP's __call method:
<?php
class Example{
    public function __call($name, $arguments){
        switch($name){
            case 'foo':
                switch(count($arguments)){
                    case 2:
                        echo 'You called "foo" with two arguments.<br>' . PHP_EOL;
                        break;
                    case 3:
                        echo 'You called "foo" with three arguments.<br>' . PHP_EOL;
                        break;
                    default:
                        echo 'Error: Invalid number of arguments to "foo."<br>' . PHP_EOL;
                        break;
                }
                break;
            default:
                echo "Error: Call to undefined function \"$name.\"<br>" . PHP_EOL;
        }
    }
}

$test = new Example;
$test->foo('bar', 'baz');
$test->foo('bar', 'baz', 'fez', 'fap');
$test->bar();
?>

troggy dot brains at gmx dot de (2009-05-19 12:17:41)

Just another note about using __get() & __set() on array properties with PHP v5.2.0.
Took me quite a while to find out why I couldn't write an array property that was created via __set(). Now a few notes earlier someone described a working solution using the ArrayObject-class. This does work, but has a big downside, you cannot expect other programmers to know that they will be getting an instance of ArrayObject instead of a native array, and trying to do an implode() on an ArrayObject will just not work. So, here is my solution to the problem:

<?php
class A {
  private $properties = array();

  public function __set($key, $value) {
    if (is_array($value)) {
      $this->$key = $value;
    } else {
      $this->properties[$key] = $value;
    }
  }

  public function __get($key) {
    if (array_key_exists($key, $this->properties)) {
      return $this->properties[$key];
    }

    return null;
  }
}
?>

The idea behind this is, that you can register new properties at any time from within a class without getting a warning or some of that kind. Now, if you try to set a property from outside the class, the __set() method will be called and decides whether to place the new property in the properties array or declare it as a new "native" property. When trying to get that property, the __get() method will only be called if the property is not "native", which won't be the case for an array.

HTH

daevid at daevid dot com (2009-05-14 21:16:27)

Here's a handy little routine to suggest properties you're trying to set that don't exist. For example:

Attempted to __get() non-existant property/variable 'operator_id' in class 'User'.

checking for operator and suggesting the following:

    * id_operator
    * operator_name
    * operator_code

enjoy.

<?php
    /**
     * Suggests alternative properties should a __get() or __set() fail
     *
     * @param     string $property
     * @return string
     * @author Daevid Vincent [daevid@daevid.com]
     * @date    05/12/09
     * @see        __get(), __set(), __call()
     */
    public function suggest_alternative($property)
    {
        $parts = explode('_',$property);
        foreach($parts as $i => $p) if ($p == '_' || $p == 'id') unset($parts[$i]);

        echo 'checking for <b>'.implode(', ',$parts)."</b> and suggesting the following:<br/>\n";

        echo "<ul>";
        foreach($this as $key => $value)
            foreach($parts as $p)
                if (stripos($key, $p) !== false) print '<li>'.$key."</li>\n";
        echo "</ul>";
    }

just put it in your __get() or __set() like so:

    public function __get($property)
    {
            echo "<p><font color='#ff0000'>Attempted to __get() non-existant property/variable '".$property."' in class '".$this->get_class_name()."'.</font><p>\n";
            $this->suggest_alternative($property);
            exit;
    }
?>

niehztog (2009-02-14 10:59:15)

If you got a parent class agregating(not inheriting) a number of child classes in an array, you can use the following to allow calling methods of the parent object on agregated child objects:
<?php
class child {
    public $holder = null;

    public function __call($name, $arguments) {
        if($this->holder instanceof parentClass && method_exists($this->holder, $name)) {
            return call_user_func_array(array($this->holder, $name), $arguments);
        }
        else {
            trigger_error();
        }
    }
}

class parentClass {
    private $children = array();

    function __construct() {
        $this->children[0] = new child();
        $this->children[0]->holder = $this;
    }

    function getChild($number) {
        if(!isset($this->children[$number])) {
            return false;
        }
        return $this->children[$number];
    }

    function test() {
        return 'it works';
    }
}

$parent = new parentClass();
$firstChild = $parent->getChild(0);
echo $firstChild->test(); //should output 'it works'
?>

jorge dot hebrard at gmail dot com (2008-12-23 16:55:47)

This is a great way to give different permissions to parent classes.

<?php
class A{
    private $b;
    function foo(){
        $this->b = new B;
        echo $this->b->protvar;
    }
}
class B extends A{
    protected $protvar="protected var";
    public function __get($nm) {
       echo "Default $nm value";
    }
}
$a = new A;
$b = new B;
$a->foo(); // prints "protected var"
echo $b->protvar; // prints "Default protvar value"
?>
This way, you can help parent classes to have more power with protected members.

Ant P. (2008-12-21 08:40:59)

Be extra careful when using __call(): if you typo a function call somewhere it won't trigger an undefined function error, but get passed to __call() instead, possibly causing all sorts of bizarre side effects.
In versions before 5.3 without __callStatic, static calls to nonexistent functions also fall through to __call!
This caused me hours of confusion, hopefully this comment will save someone else from the same.

erick2711 at gmail dot com (2008-11-14 07:33:54)

<?php
/***********************************************
 *And here follows a child class which implements a menu based in the 'nodoMenu' class (previous note).
 *
 *[]s
 *
 *erick2711 at gmail dot com
 ************************************************/
class menu extends nodoMenu{
    private $cssc = array();
    
    public function __toString(){  //Just to show, replace with something better.
        $stringMenu = "<pre>\n";$stringMenu .= $this->strPrint();$stringMenu .= "</pre>\n";
        return $stringMenu;
    }

    public function __construct($cssn = null){
        parent::__construct();
        if (isset($cssn) && is_array($cssn)){$this->cssc = $cssn;}
        $this->buildMenu();
    }
    
    public function buildMenu(){
        $this->add('server',
                   'Server',
                   'server.php');
            $this->server->add('personalD',
                               'Personal Data',
                               'server/personal.php');
            $this->server->add('personalI',
                               'Personal Interviews',
                               'server/personalI.php');
                $this->server->personalI->add('detailsByIer',
                                              'Detalis by Interviewer',
                                              'server/personalI.php?tab=detailsByIer');
        //(...)
        return $this;
    }
}

//Testing
$meuMenu = new menu;
echo $meuMenu;
/***********************************************
 *Will output (to the browser):
 *
 *<pre>
 *1 Server<br>
 *??1.1 Personal Data<br>
 *??1.2 Personal Interviews<br>
 *??????1.2.1 Details by Interviewer<br>
 *</pre>
 *
 *Which shows:
 *
 *1 Server
 *  1.1 Personal Data
 *  1.2 Personal Interviews
 *      1.2.1 Details by Interviewer
 ************************************************/
?>

erick2711 at gmail dot com (2008-11-14 07:09:53)

<?php
/*
    Here folows a little improvement of the 'strafvollzugsbeamter at gmx dot de' code, allowing each node to hold both 'parameters' and 'child nodes', and differentiate $s->A->B->C ('FOO') from $s->A (same 'FOO', but shouldn't exist) and from $s-A->B (idem).
    This allows the class, using the interesting suggested syntax ($root->dad->child->attribute, in which 'dad's and 'child's names are dynamically generated), to do something actually useful, like implementing a n-tree data structure (a menu, for instance).
    It was tested under PHP 5.2.6 / Windows.
    I know that must there be something better which already do this (probably in the DOM Model classes, or something like), but it was fun to develop this one, for the sake of studying the "magic" methods.
    Its a compressed version of the code (no comments, too short variable names, almost no identation). I had to compress it in order to add the note. If anyone cares about the full version, just email me.
    []s
    
    erick2711 at gmail dot com
*/
class nodoMenu{

    protected $p  = array();
    protected $c = array();

    public function __construct($t = '', $uri = '', $css = null, $n = 0, $i=0){
        $this->p['t'] = $t;$this->p['uri'] = $uri;$this->p['css'] = $css;$this->p['n'] = $n;$this->p['i'] = $i;$this->p['q'] = 0;return $this;
    }

    public function add($cn, $ct = '', $cl = '', $css = null){
        $nc = new nodoMenu($ct, $cl, $css, $this->p['n'] + 1, $this->p['q']);$this->c[$cn] = $nc;$this->p['q'] += 1;return $this->c[$cn];
    }

    private function isParameter($pn){
        return array_key_exists($pn, $this->p);
    }
    
    public function __isset($pn){
        if ($this->isParameter($pn)){return(!is_null($this->p[$pn]));}
        else{return(array_key_exists($pn, $this->c));}
    }

    public function remove($cn){
        if (array_key_exists($cn, $this->c)){$this->p['q'] -= 1;unset($this->c[$cn]);}
    }

    public function __unset($pn){
        if ($this->isParameter($pn)){$this->p[$pn] = null;}
        else{$this->remove($pn);}
    }

    public function __set($pn, $v){
        $r = null;
        if ($this->isParameter($pn)){$this->p[$pn] = $v;$r = $v;}
        else{if (array_key_exists($pn, $this->c)){$this->c[$pn] = $v;$r = $this->c[$pn];}
            else{$r = $this->add($pn);}}    
        return $r;
    }        

    public function __get($pn){
        $v = null;
        if ($this->isParameter($pn)){$v = $this->p[$pn];}
        else{if (array_key_exists($pn, $this->c)){$v = $this->c[$pn];}
            else{$v = $this->add($pn);}}
        return $v;
    }
    
    public function hasChilds(){
        return(isset($this->c[0]));
    }
    
    public function child($i){
        return $this->c[$i];
    }
    
    public function strPrint($bm = ''){   //Just to show, replace with something better.
        $m = '';$r = '';$n = $this->p['n'];
        if ($n > 0){switch($n){case 0:case 1: $qs = 0; break;case 2: $qs = 2; break;case 3: $qs = 6; break;case 4: $qs = 12; break;case 5: $qs = 20; break;case 6: $qs = 30; break;case 7: $qs = 42; break;case 8: $qs = 56; break;}
            $tab = str_repeat('&nbsp;', $qs);$r .= $tab;
            if ($bm <> ''){$m = $bm.'.';}
            $im = $this->p['i'] + 1;$m .= $im;$r .= $m.' ';$r .= $this->p['t']."<br>\n";
        }
        foreach ($this->c as $child){$r .= $child->strPrint($m);}
        return $r;
    }
    
    public function __toString(){
        return $this->strPrint();
    }
}
?>

Ant P. (2008-08-30 07:01:53)

There's nothing wrong with calling these functions as normal functions:

If you end up in a situation where you need to know the return value of your __set function, just write <?php $a = $obj->__set($var, $val); ?> instead of <?php $a = $obj->$var = $val; ?>.

strafvollzugsbeamter at gmx dot de (2008-07-16 12:57:09)

The following works on my installation (5.2.6 / Windows):
<?php
class G
{
    private $_p = array();
    
    public function __isset($k)
    {
        return isset($this->_p[$k]);
    }
        
    public function __get($k)
    {
        $v = NULL;
        if (array_key_exists($k, $this->_p))
        {
            $v = $this->_p[$k];
        }
        else
        {
            $v = $this->{$k} = $this;
        }
        
        return $v;
    }
    
    public function __set($k, $v)
    {
        $this->_p[$k] = $v;
        
        return $this;
    }    
}

$s = new G();
$s->A->B->C = 'FOO';
$s->X->Y->Z = array ('BAR');

if (isset($s->A->B->C))
{
    print($s->A->B->C);
}
else
{
    print('A->B->C is NOT set');
}

if (isset($s->X->Y->Z))
{
    print_r($s->X->Y->Z);
}
else
{
    print('X->Y->Z is NOT set');
}

// prints: FOOArray ( [0] => BAR )
?>

... have fun and  ...

Anonymous (2008-04-30 13:02:54)

This is a generic implementation to use getter, setter, issetter and unsetter for your own classes.

<?php
abstract class properties
{
  public function __get( $property )
  {
    if( ! is_callable( array($this,'get_'.(string)$property) ) )
      throw new BadPropertyException($this, (string)$property);

    return call_user_func( array($this,'get_'.(string)$property) );
  }

  public function __set( $property, $value )
  {
    if( ! is_callable( array($this,'set_'.(string)$property) ) )
      throw new BadPropertyException($this, (string)$property);

    call_user_func( array($this,'set_'.(string)$property), $value );
  }
  
  public function __isset( $property )
  {
    if( ! is_callable( array($this,'isset_'.(string)$property) ) )
      throw new BadPropertyException($this, (string)$property);

    return call_user_func( array($this,'isset_'.(string)$property) );
  }

  public function __unset( $property )
  {
    if( ! is_callable( array($this,'unset_'.(string)$property) ) )
      throw new BadPropertyException($this, (string)$property);

    call_user_func( array($this,'unset_'.(string)$property) );
  }
}
?>

nospam michael AT netkey DOT at nospam (2008-04-01 10:10:53)

you CAN write into ARRAYS by using __set and __get magic functions. 

as has been mentioned before $obj->var['key'] = 'test'; does call the __get method of $obj, and there is no way to find out, if the method has been called for setting purposes.

the solution is quite simple: use __get to return the array by reference. then you can write into it:

<?php
class setter{
  private $_arr = array();

  public function __set($name, $value){
    $this->_arr[$name] = $value;
  }

  public function &__get($name){
    if (isset($this->_arr[$name])){
      return $this->_arr[$name];
    } else return null;
  }

}

?>

Matt Creenan (2008-02-29 08:34:16)

PHP4 supports using __call but with a twist that I did not see mentioned anywhere on this page.

In 4, you must make the __call method signature with 3 parameters, the 3rd of which is the return value and must be declared by-reference.  Instead of using "return $value;" you would assign the 3rd argument to $value.

Example (both implementations below have the same result when run in the respective PHP versions:

<?php

// Will only work in PHP4
class Foo
{
    function __call($method_name, $parameters, &$return_value)
    {
        $return_value = "Method $method_name was called with " . count($parameters) . " parameters";
    }
}

// Will only work in PHP5
class Foo
{
    function __call($method_name, $parameters)
    {
        return "Method $method_name was called with " . count($parameters) . " parameters";
    }
}

?>

dave at mozaiq dot org (2008-02-10 15:58:24)

Several users have mentioned ways to allow setting of array properties via magic methods. In particular, PHP calls the __get() method instead of the __set() method when you try to do: $obj->prop['offset'] = $val.

The suggestions that I've read below all work, except that they do not allow you make properties read-only. After a bit of struggling, I have found a solution. Essentially, if the property is supposed to be a read-only array, create an new ArrayObject() out of it, then clone it and return the clone.

<?php

public function __get($var) {
    if(isset($this->read_only_props[$var])) {
        $ret = null;
        if (is_array($this->read_only_props[$var]))
            return clone new ArrayObject($this->read_only_props[$var]);
        else if (is_object($this->read_only_props[$var]))
            return clone $this->read_only_props[$var];
        else
            return $this->read_only_props[$var];
    }
    else if (!isset($this->writeable_props[$var])) 
        $this->writeable_props[$var] = NULL;
    return $this->writeable_props[$var];
}

public function __set($var, $val) {
    if (isset($this->read_only_props[$var]))
        throw new Exception('tried to set a read only property on the event object');
    return $this->writeable_props[$var] = $val;
}
?>

Note that __get() does not explicitly return by reference as many examples have suggested. Also, I have not found a way to detect when __get() is being called for setting purposes, thus my code can not throw an exception when necessary in these cases.

timshaw at mail dot NOSPAMusa dot com (2008-01-28 21:47:10)

The __get overload method will be called on a declared public member of an object if that member has been unset.

<?php
class c {
  public $p ;
  public function __get($name) { return "__get of $name" ; }
}

$c = new c ;
echo $c->p, "\n" ;    // declared public member value is empty
$c->p = 5 ;
echo $c->p, "\n" ;    // declared public member value is 5
unset($c->p) ;
echo $c->p, "\n" ;    // after unset, value is "__get of p"
?>

jj dhoT maturana aht gmail dhot com (2008-01-25 04:16:05)

There isn't some way to overload a method when it's called as a reflection method:

<?php

class TestClass {
  function __call($method, $args) {
    echo "Method {$method} called with args: " . print_r($args, TRUE);
  }
}

$class = new ReflectionClass("TestClass");
$method = $class->getMethod("myMehtod");

//Fatal error:  Uncaught exception 'ReflectionException' with message 'Method myMethod' does not exist'

?>

Juan.

v dot umang at gmail dot com (2008-01-11 21:20:13)

If you want to be able to overload a variable from within a class and this is your code:
<?php
class myClass
{
    private $data;
    public function __set($var, $val)
    {
        $this->data[$var] = $val;
    }
    public function __get($var)
    {
        $this->data[$var] = $val;
    }
}
?>

There is a problem if you want to call these variables from within the class, as you you want to access data['data'] then you can't say $this->data as it will return the array $data. Therefore a simple solution is to name the array $_data. So in your __get and __set you will say $this->_data ... rather than $this->data. I.E:
<?php
class myClass
{
    private $_data;
    public function __set($var, $val)
    {
        $this->_data[$var] = $val;
    }
    public function __get($var)
    {
        $this->_data[$var] = $val;
    }
}
?>

Umang

soldair at NOSPAM gmail.com (2008-01-10 09:21:07)

the documentation states a falsehood:
 "All overloading methods must be defined as public."

<?php
class test{
    #################
    #public use methods#
    #################
    public static function echoData(){
        $obj = self::getInstance();
        echo $obj->find('data');
        return true;
    }
    ######################
    #only use a single instance#
    ######################
    private static $instance;
    private static function getInstance(){
        if(!isset(self::$instance)){
            self::$instance = new test;
        }
        return self::$instance;
    }
    #################
    #private instantiation#
    #################
    private $data = array('data'=>'i am data');
    private function __construct(){}
    private function __call($nm,$args){
        if(isset($this->data[$args[0]])){
            return $this->data[$args[0]];
        }
        return null;
    }
}

test::echoData();
?>
--------------OUTPUT---------------
i am data
-----------------------------------

this test was run using PHP Version 5.2.4

Anonymous (2008-01-09 07:45:50)

it should be noted that __call will trigger only for method calls on an instantiated object, and cannot be used to 'overload' static methods.  for example:

<?php

class TestClass {
  function __call($method, $args) {
    echo "Method {$method} called with args: " . print_r($args, TRUE);
  }
}

// this will succeed
$obj = new TestClass();
$obj->method_doesnt_exist();

// this will not
TestClass::method_doesnt_exist();

?>

It would be useful if the PHP devs would include this in a future release, but in the meantime, just be aware of that pitfall.

egingell at sisna dot com (2007-12-20 19:54:52)

The PHP devs aren't going to implement true overloading because: PHP is not strictly typed by any stretch of the imagination (0, "0", null, false, and "" are the same, for example) and unlike Java and C++, you can pass as many values as you want to a function. The extras are ignored unless you fetch them using func_get_arg(int) or func_get_args(), which is often how I "overload" a function/method, and fewer than the declared number of arguments will generate an E_WARNING, which can be suppressed by putting '@' before the function call, but the function will still run as if you had passed null where a value was expected.

<?php
class someClass {
    function whatever() {
        $args = func_get_args();
    
        // public boolean whatever(boolean arg1) in Java
        if (is_bool($args[0])) {
            // whatever(true);
            return $args[0];
    
        // public int whatever(int arg1, boolean arg2) in Java
        } elseif(is_int($args[0]) && is_bool($args[1])) {
            // whatever(1, false)
            return $args[0];
    
        } else {
            // public void whatever() in Java
            echo 'Usage: whatever([int], boolean)';
        }
    }
}
?>

// The Java version:
public class someClass {
    public boolean whatever(boolean arg1) {
        return arg1;
    }
    
    public int whatever(int arg1, boolean arg2) {
        return arg1;
    }
    
    public void whatever() {
        System.out.println("Usage: whatever([int], boolean)");
    }
}

matthijs at yourmediafactory dot com (2007-12-16 11:09:20)

While PHP does not support true overloading natively, I have to disagree with those that state this can't be achieved trough __call. 

Yes, it's not pretty but it is definately possible to overload a member based on the type of its argument. An example:
<?php 
class A { 
   
  public function __call ($member, $arguments) { 
    if(is_object($arguments[0])) 
      $member = $member . 'Object'; 
    if(is_array($arguments[0])) 
      $member = $member . 'Array'; 
    $this -> $member($arguments); 
  } 
   
  private function testArray () { 
    echo "Array."; 
  } 
   
  private function testObject () { 
    echo "Object."; 
  } 
} 

class B { 
} 

$class = new A; 
$class -> test(array()); // echo's 'Array.' 
$class -> test(new B); // echo's 'Object.' 
?>

Of course, the use of this is questionable (I have never needed it myself, but then again, I only have a very minimalistic C++ & JAVA background). However, using this general principle and optionally building forth on other suggestions a 'form' of overloading is definately possible, provided you have some strict naming conventions in your functions. 

It would of course become a LOT easier once PHP'd let you declare the same member several times but with different arguments, since if you combine that with the reflection class 'real' overloading comes into the grasp of a good OO programmer. Lets keep our fingers crossed!

anthony dot parsons at manx dot net (2007-11-09 14:57:35)

You can't use __set to set arrays, but if you really want to, you can emulate it yourself:
<?php
class test {
    public $x = array();
    public $y = array();
    function __set($var, $value)
    {
        if ( preg_match('/(.*)\[(.*)\]/', $var, $names) ) {
            $this->y[$names[1]][$names[2]] = $value;
        }
        else {
            $this->x[$var] = $value;
        }
    }
}

$z = new test;
$z->variable = 'abc';
$z->{'somearray[key]'} = 'def';

var_dump($z->x);
var_dump($z->y);
?>

php_is_painful at world dot real (2007-10-19 07:49:21)

This is a misuse of the term overloading. This article should call this technique "interpreter hooks".

bgoldschmidt at rapidsoft dot de (2007-09-28 01:23:15)

"These methods will only be triggered when your object or inherited object doesn't contain the member or method you're trying to access."
is not quite correct:
they get called when the member you trying to access in not visible:

<?php
class test {

  public $a;
  private $b;

  function __set($name, $value) {
    echo("__set called to set $name to $value\n");
    $this->$name = $value;
  }
}

$t = new test;
$t->a = 'a';
$t->b = 'b';

?>

Outputs:
__set called to set b to b

Be aware that set ist not called for public properties

lokrain at gmail dot com (2007-09-26 02:05:21)

Let us look at the following example:

<?php
class objDriver {
    private $value;

    public function __construct()
    {
        $value = 1;
    }

    public function doSomething($parameterList)
    {
        //We make actions with the value
    }
}

class WantStaticCall {
    private static $objectList;

    private function __construct()

    public static function init()
    {
         self::$objectList = array();
    }

    public static function register($alias)
    {
        self::$objectList[$alias] = new objDriver();
    }

    public static function __call($method, $arguments)
    {
        $alias = $arguments[0];
    array_shift($arguments);
        call_user_method($method, self::$objectList[$alias], $arguments);
    }
}

// The deal here is to use following code:
WantStaticCall::register('logger');
WantStaticCall::doSomething('logger', $argumentList);

// and we will make objDriver to call his doSomething function with arguments
// $argumentList. This is not common pattern but very usefull in some cases.
// The problem here is that __call() cannot be static, Is there a way to work it around
?>

Typer85 at gmail dot com (2007-09-18 08:28:50)

Just to clarify something the manual states about method overloading.
"All overloading methods must be defined as public."
As of PHP 5.2.2, this should be considered more of a coding convention rather than a requirement. In PHP 5.2.2, declaring a __get or __set function with a visibility other than public, will be silently ignored by the parser and will not trigger a parse error!
What is more, PHP will completely ignore the visibility modifier either of these functions are declared with and will always treat them as if they were public.
I am not sure if this is a bug or not so to be on the safe side,
stick with always declaring them public.

egingell at sisna dot com (2007-09-15 05:12:49)

Small vocabulary note: This is *not* "overloading", this is "overriding".

Overloading: Declaring a function multiple times with a different set of parameters like this:
<?php

function foo($a) {
    return $a;
}

function foo($a, $b) {
    return $a + $b;
}

echo foo(5); // Prints "5"
echo foo(5, 2); // Prints "7"

?>

Overriding: Replacing the parent class's method(s) with a new method by redeclaring it like this:
<?php

class foo {
    function new($args) {
        // Do something.
    }
}

class bar extends foo {
    function new($args) {
        // Do something different.
    }
}

?>

ac221 at sussex dot ac dot uk (2007-09-01 10:07:04)

Just Noting the interesting behavior of __set __get , when modifying objects contained in overloaded properties.

<?php
class foo {
    public $propObj;
    public function __construct(){
        $propObj = new stdClass();
    }
    public function __get($prop){
        echo("I'm Being Got ! \n"); 
        return $this->propObj->$prop;
    }
    public function __set($prop,$val){
        echo("I'm Being Set ! \n");
        $this->propObj->$prop = $val;
    }
}
$test = new foo();
$test->barProp = new stdClass(); // I should invoke set
$test->barProp->barSubProp = 'As Should I';
$test->barProp->barSubProp = 'As Should I';
$test->barProp = new stdClass(); // As should i
?>

Outputs:

I'm Being Set !
I'm Being Got !
I'm Being Got !
I'm Being Set !

Whats happening, is PHP is acquiring a reference to the object, triggering __get; Then applying the changes to the object via the reference.

Which is the correct behaviour; objects being special creatures, with an aversion to being cloned...

Unfortunately this will never invoke the __set handler, even though it is modifying a property within 'foo', which is slightly annoying if you wanted to keep track of changes to an objects overloaded properties.

I guess Journaled Objects will have to wait till PHP 6 :)

stephen dot cuppett at webmastersinc dot net (2007-08-16 07:10:55)

Please note, this example will not work on later PHP versions. You must return from __get() by reference using &__get()

php at sleep is the enemy dot co dot uk (2007-07-23 07:23:43)

Just to reinforce and elaborate on what DevilDude at darkmaker dot com said way down there on 22-Sep-2004 07:57.

The recursion detection feature can prove especially perilous when using __set. When PHP comes across a statement that would usually call __set but would lead to recursion, rather than firing off a warning or simply not executing the statement it will act as though there is no __set method defined at all. The default behaviour in this instance is to dynamically add the specified property to the object thus breaking the desired functionality of all further calls to __set or __get for that property.

Example:

<?php

class TestClass{

    public $values = array();
    
    public function __get($name){
        return $this->values[$name];
    }
    
    public function __set($name, $value){
        $this->values[$name] = $value;
        $this->validate($name);
    }

    public function validate($name){
        /*
        __get will be called on the following line
        but as soon as we attempt to call __set 
        again PHP will refuse and simply add a 
        property called $name to $this 
        */
        $this->$name = trim($this->$name);
    }
}

$tc = new TestClass();

$tc->foo = 'bar';
$tc->values['foo'] = 'boing';

echo '$tc->foo == ' . $tc->foo . '<br>';
echo '$tc ' . (property_exists($tc, 'foo') ? 'now has' : 'still does not have') . ' a property called "foo"<br>';

/*
OUPUTS:
$tc->foo == bar
$tc now has a property called "foo"
*/

?>

Adeel Khan (2007-07-10 13:18:39)

Observe:

<?php
class Foo {
    function __call($m, $a) {
        die($m);
    }
}

$foo = new Foo;
print $foo->{'wow!'}();

// outputs 'wow!'
?>

This method allows you to call functions with invalid characters.

alexandre at nospam dot gaigalas dot net (2007-07-07 22:59:35)

PHP 5.2.1

Its possible to call magic methods with invalid names using variable method/property names:

<?php

class foo
{
    function __get($n)
    {
        print_r($n);
    }
    function __call($m, $a)
    {
        print_r($m);
    }
}

$test = new foo;
$varname = 'invalid,variable+name';
$test->$varname;
$test->$varname();

?>

I just don't know if it is a bug or a feature :)

BenBE at omorphia dot de (2007-05-05 10:48:42)

While playing a bit with the __call magic method I found you can not emulate implementing methods of an interface as you might think:

<?php
class Iteratable implements Iterator {
    public function __call($funcname) {
        if(in_array($funcname, array('current', 'next', /*...*/)) {
            //Redirect the call or perform the actual action
        }
    }
}
?>

Using this code you'll get a "class Iteratable contains abstract methods ..." fatal error message. You'll ALWAYS have to implement those routines by hand.

mafu at spammenot-mdev dot dk (2007-02-24 14:24:36)

As a reply to james at thunder-removeme-monkey dot net, I found that there is a much simpler way to restore the behavior of __get() to 5.1.x state; just force __get() to return by reference, like this:

<?php
class View {
  /* Somewhere to store our overloaded properties */
  private $v = array();

  /* Store a new property */
  function __set($varName, $varValue) {
   $this->v[$varName] = $varValue;
  }

  /* Retrieve a property */
  function & __get($varName) {
   if(!isset($this->v[$varName])) {
     $this->v[$varName] = NULL;
   }
   return $this->v[$varName];
  }
}
?>

The only problem is that the code generates a notice if null is returned in __get(), because null cannot be returned by reference. If somebody finds a solution, feel free to email me. :)

Cheers

james at thunder-removeme-monkey dot net (2007-01-31 13:07:33)

Following up on the comment by "jstubbs at work-at dot co dot jp" and after reading "http://weierophinney.net/matthew/archives/ 131-Overloading-arrays-in-PHP-5.2.0.html", the following methods handle property overloading pretty neatly and return variables in read/write mode.

<?php
class View {
  /* Somewhere to store our overloaded properties */
  private $v = array();

  /* Store a new property */
  function __set($varName, $varValue) {
    $this->v[$varName] = $varValue;
  }

  /* Retrieve a property */
  function __get($varName) {
    if(!isset($this->v[$varName])) {
      $this->v[$varName] = NULL;
    }
    return is_array($this->v[$varName]) ? new ArrayObject($this->v[$varName]) : $this->v[$varName];
  }
}
?>

This is an amalgm of previous solutions with the key difference being the use of ArrayObject in the return value. This is more flexible than having to extend the whole class from ArrayObject.

Using the above class, we can do ...

<?php
$obj = new SomeOtherObject();
$view = new View();

$view->list = array();
$view->list[] = "hello";
$view->list[] = "goat";
$view->list[] = $group;
$view->list[] = array("a", "b", "c");
$view->list[3][] = "D";
$view->list[2]->aprop = "howdy";

/*
$view->list now contains:
[0] => "hello"
[1] => "goat"
[2] => SomeOtherObject { aprop => "howdy" }
[3] => array("a", "b", "c", "D")

and
$obj === $view->list[2] // equates to TRUE
*/
?>

mhherrera31 at hotmail dot com (2006-11-25 10:11:06)

example for read only properties in class object. Lets you manage read only properties with var names like $ro_var.

The property must be PRIVATE, otherwise the overload method __get doesn't be called.

<?php
class Session {
 private $ro_usrName;

 function __construct (){
  $this->ro_usrName = "Marcos";
 }

 function __set($set, $val){
  if(property_exists($this,"ro_".$set))
    echo "The property '$set' is read only";
  else
    if(property_exists($this,$set))
      $this->{$set}=$val;
    else
      echo "Property '$set' doesn't exist";
 }

 function __get{$get}{
  if(property_exists($this,"ro_".$get))
    return $this->{"ro_".$get};
  else
    if(property_exists($this,$get))
     return $this->{$get};
    else
     echo "Property '$get' doesn't exist";
 }
}
?>

MagicalTux at ooKoo dot org (2006-09-06 02:35:29)

Since many here probably wanted to do ?real? overloading without having to think too much, here's a generic __call() function for those cases.

Little example :
<?php
class OverloadedClass {
        public function __call($f, $p) {
                if (method_exists($this, $f.sizeof($p))) return call_user_func_array(array($this, $f.sizeof($p)), $p);
                // function does not exists~
                throw new Exception('Tried to call unknown method '.get_class($this).'::'.$f);
        }

        function Param2($a, $b) {
                echo "Param2($a,$b)\n";
        }

        function Param3($a, $b, $c) {
                echo "Param3($a,$b,$c)\n";
        }
}

$o = new OverloadedClass();
$o->Param(4,5);
$o->Param(4,5,6);
$o->ParamX(4,5,6,7);
?>

Will output :
Param2(4,5)
Param3(4,5,6)

Fatal error: Uncaught exception 'Exception' with message 'Tried to call unknown method OverloadedClass::ParamX' in overload.php:7
Stack trace:
#0 [internal function]: OverloadedClass->__call('ParamX', Array)
#1 overload.php(22): OverloadedClass->ParamX(4, 5, 6, 7)
#2 {main}
  thrown in overload.php on line 7

jstubbs at work-at dot co dot jp (2006-09-02 09:12:49)

<?php $myclass->foo['bar'] = 'baz'; ?>
 
When overriding __get and __set, the above code can work (as expected) but it depends on your __get implementation rather than your __set. In fact, __set is never called with the above code. It appears that PHP (at least as of 5.1) uses a reference to whatever was returned by __get. To be more verbose, the above code is essentially identical to:
 
<?php
$tmp_array = &$myclass->foo;
$tmp_array['bar'] = 'baz';
unset($tmp_array);
?>

Therefore, the above won't do anything if your __get implementation resembles this:

<?php 
function __get($name) {
    return array_key_exists($name, $this->values)
        ? $this->values[$name] : null;
}
?>

You will actually need to set the value in __get and return that, as in the following code:

<?php
function __get($name) {
    if (!array_key_exists($name, $this->values))
        $this->values[$name] = null;
    return $this->values[$name];
}
?>

mnaul at nonsences dot angelo dot edu (2006-07-11 12:58:46)

This is just my contribution. It based off of many diffrent suggestions I've see thought the manual postings.
It should fit into any class and create default get and set methods for all you member variables. Hopfuly its usefull.
<?php
    public function __call($name,$params)
    {
        if( preg_match('/(set|get)(_)?/',$name) )
        {
            if(substr($name,0,3)=="set")
            {
                $name = preg_replace('/set(_)?/','',$name);
                if(property_exists(__class__,$name))
                {
                        $this->{$name}=array_pop($params);
                    return true;
                }
                else
                {
                    //call to class error handler
                    return false;
                }
                return true;
            }
            elseif(substr($name,0,3)=="get")
            {
                $name = preg_replace('/get(_)?/','',$name);
                if(property_exists(__class__,$name) )
                {
                    return $this->{$name};
                }
                else
                {
                    //call to class error handler
                    return false;
                }
            }
            else
            {
                //call to class error handler
                return false;
            }
        }
        else
        {
            die("method $name dose not exist\n");
        }
        return false;
    }

me at brenthagany dot com (2006-04-12 10:52:04)

Regarding the post by TJ earlier, about the problems extending DOMElement.  Yes, it is true that you can't set extDOMElement::ownerDocument directly; however, you could append the extDOMElement to a DOMDocument in __construct(), which indirectly sets ownerDocument.  It should work something like so:

<?php
class extDOMElement extends DOMElement {

  public function __construct(DOMDocument $doc) {
    $doc->appendChild($this);  //extDOMElement::ownerDocument is now equal to the object that $doc points to
  }
}
?>

Now, I admit I've never actually needed to do this, but I see no reason why it shouldn't work.

Sleepless (2006-02-23 23:22:40)

Yet another way of providing support for read-only properties.  Any property that has
"pri_" as a prefix will NOT be returned, period, any other property will be returned 
and if it was declared to be "protected" or "private" it will be read-only. (scope dependent of course)

<?php
function __get($var){
        if (property_exists($this,$var) && (strpos($var,"pri_") !== 0) )
            return $this->{$var};
        else
            //Do something
}
?>

Eric Lafkoff (2006-02-21 22:56:02)

If you're wondering how to create read-only properties for your class, the __get() and __set() functions are what you're looking for. You just have to create the framework and code to implement this functionality. 

Here's a quick example I've written. This code doesn't take advantage of the "type" attribute in the properties array, but is there for ideas.

<?php

class Test {
    
    private $p_arrPublicProperties = array(
            "id" => array("value" => 4,
                    "type" => "int",
                    "readonly" => true),
            "datetime" => array("value" => "Tue 02/21/2006 20:49:23",
                    "type" => "string", 
                    "readonly" => true),
            "data" => array("value" => "foo", 
                    "type" => "string", 
                    "readonly" => false)
            );

    private function __get($strProperty) {
        //Get a property:
        if (isset($this->p_arrPublicProperties[$strProperty])) {
            return $this->p_arrPublicProperties[$strProperty]["value"];
        } else {
            throw new Exception("Property not defined");
            return false;
        }
    }
    
    private function __set($strProperty, $varValue) {
        //Set a property to a value:
        if (isset($this->p_arrPublicProperties[$strProperty])) {
            //Check if property is read-only:
            if ($this->p_arrPublicProperties[$strProperty]["readonly"]) {
                throw new Exception("Property is read-only");
                return false;
            } else {
                $this->p_arrPublicProperties[$strProperty]["value"] = $varValue;
                return true;
            }
        } else {
            throw new Exception("Property not defined");
            return false;
        }
    }
    
    private function __isset($strProperty) {
        //Determine if property is set:
        return isset($this->p_arrPublicProperties[$strProperty]);
    }
    
    private function __unset($strProperty) {
        //Unset (remove) a property:
        unset($this->p_arrPublicProperties[$strProperty]);
    }    
            
}

$objTest = new Test();

print $objTest->data . "\n";

$objTest->data = "bar"; //Works.
print $objTest->data;

$objTest->id = 5; //Error: Property is read-only.

?>