View difference between Paste ID: i7xpYuLe and NccJtwEU

 <?php
 
 abstract class Component extends stdCLass implements ArrayAccess, Countable
 {
 	protected $Decorators	= array();
 	protected $Water		= 0;
 	protected $SharedProps  = 0;
 
 	public function GetProperties(Component $Child)
 	{
 		foreach($this as $k => $v)
 		{
 			$Child->{$k} = &$this->{$k};
 		}
 
 		if(!isset($this->datahash))
 		{
 			$Child->base 	 = &$this;
 			$Child->datahash = spl_object_hash($this);
 		}
 	}
 
 	public function AddDecorator($func, $args = array())
 	{
 		if(is_callable($func))
 		{
 			array_push($this->Decorators, array($func, $args));
 		}
 		else
 		{
 			throw new InvalidArgumentException(sprintf('%s::AddDecorator(callable $func, array $args): Invalid function ( %s ).', get_class($this), var_export($func, true)));
 		}
 	}
 
 	public function RemoveDecorator($func, $args = array())
 	{
 		foreach($this->Decorators as & $decorator)
 		{
 			if($decorator === array($func, $args))
 			{
 				unset($decorator);
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	public function Decorate()
 	{
 		foreach($this->Decorators as $call)
 		{
 			call_user_func_array($call[0], $call[1]);
 		}
 	}
 
 	public function __call($Key, $Params)
 	{
 		$prev = debug_backtrace();
 		$Key  = (string)$Key;
 		$base = isset($this->base)
 			? $this->base
 			: $this
 		;
 
 		if(!isset($this->{$Key}) && !isset($base->{$Key}))
 		{
 			throw new BadMethodCallException(sprintf('Call to undefined method `%s::%s()`', get_class($this), $Key));
 			return;
 		}
 
 		if(is_callable($this->{$Key}))
-			call_user_func_array($this->{$Key}, $Params);
+
 			return call_user_func_array($this->{$Key}, $Params);
 		}
 		elseif(is_callable($base->{$Key}))
-			call_user_func_array($base->{$Key}, $Params);
+
 			return call_user_func_array($base->{$Key}, $Params);
 		}
 		else
 		{
 			throw new BadMethodCallException(sprintf('Call to undefined method `%s::{%s}()`.', get_class($this), var_export($this->{$Key}, true)));
 			return;
 		}
 
 	}
 
 	private function getHash()
 	{
 		return isset($this->datahash)
 			? $this->datahash
 			: $this->datahash = spl_object_hash($this)
 		;
 	}
 
 	public function offsetSet($offset, $value)
 	{
 		static $count = 0;
 
 		$hash = $this->getHash();
 
 		if (is_null($offset))
 		{
 			$this->{$hash.$count++} = $value;
 			$this->SharedProps++;
 		}
 		else
 		{
 			if(!isset($this[$offset])) $this->SharedProps++;
 
 			$this->{$hash.$offset} = $value;
 		}
 	}
 
 	public function offsetExists($offset)
 	{
 		return isset($this->{$this->getHash().$offset});
 	}
 
 	public function offsetUnset($offset)
 	{
 		$hash = $this->getHash();
 
 		if(isset($this->{$hash.$offset})) $this->SharedProps--;
 
 		unset($this->{$hash.$offset});
 	}
 
 	public function &offsetGet($offset)
 	{
 		return $this->{$this->getHash().$offset};
 	}
 
 	public function count()
 	{
 		return count($this->SharedProps);
 	}
-	function SetFunction($name, $func)
+
 	protected function nop(){;}
 
 	public function SetFunction($name, $func = 'nop')
 	{
 		$base = isset($this->base)
 			? $this->base
 			: $this
 		;
 
 		$old = isset($base->{$name})
 			? $base->{$name}
 			: NULL
 		;
 
 		if(!is_callable(array($this, $func)))
 		{
 			var_dump($this, $func);
 
 			throw new InvalidArgumentException(sprintf('%s::SetFunction(): Undefined method `%s`', get_class($this), var_export($func, true)));
 		}
 
 		$this->{$name} = $base->{$name} = array($this, $func);
-	public function CallParent($Function)
+
 		return $old;
-		$parent	= debug_backtrace();
+
-		$parent	= get_parent_class($parent[1]['class']) or get_parent_class($this);
+
-		$args	= func_get_args();
+
 	function PourWater()
-		if(method_exists($parent, $Function))
+
 		printf('Adding Water: %d%s', $this['Water'], "\n");
-			call_user_func_array($parent.'::'.$Function, $args);
+
 }
 
 abstract class Decorator extends Component
-			call_user_func_array(array($this->parent, $Function), $args);
+
 	public function __construct(Component $Parent)
 	{
 		$this->parent = &$Parent;
 
 		$Parent->GetProperties($this);
 	}
 
 	public function __call($Key, $Params)
 	{
 		$prev	= debug_backtrace();
 		$prev	= $prev[0]['class'];
 
 		if($prev == __CLASS__)
 		{
 			if(!is_callable(array($this->parent, $Key)))
 			{
 				throw new BadMethodCallException(sprintf('Call to undefined method `%s::%s()`', get_class($this), $Key));
 				return;
 			}
 
 			return call_user_func_array(array($this->parent, $Key), $Params);
 		}
 
 		parent::__call($Key, $Params);
 	}
 }
 
 class SimpleCofee extends Component
 {
 	protected $Name			= 'Cofee';
 	protected $Cup 			= array();
 
 	public function __construct($Parent = NULL)
 	{
 		$this->Water		 = 150;
 		$this->Cup['cofeee'] = 25;
 
 		if($Parent instanceof Component)
 		{
 			$Parent->GetProperties($this);
 		}
 		else
 		{
 			$this['Name']		= $this->Name;
 			$this['Water']		= $this->Water;
 			$this['Cup']		= $this->Cup;
 		}
 
 		$this->SetFunction('Produce', 'doProduce');
 		$this->SetFunction('SuperChain', 'doSuperChain');
 	}
 
 	public function doProduce()
 	{
 		printf("Making %s....\n", $this->Name);
 
 		$this->Decorate();
 
 		//.....
 		$this->PourWater();
 		//......
 
 		printf("Making %s: %s\n", $this['Name'], var_export($this['Cup'], true));
 	}
 
 	public function doSuperChain()
 	{
 		print __CLASS__.'::SuperChain('.var_export(func_get_args(), true).")\n";
 	}
 }
 
 class SimpleTea extends SimpleCofee
 {
 	protected $Name			= 'Tea';
 
 	public function __construct($Parent = NULL)
 	{
 		$this->Water		 = 150;
 		$this->Cup['tea']	 = 25;
 
 		if($Parent instanceof Component)
 		{
 			$Parent->GetProperties($this);
 		}
 		else
 		{
 			$this['Name']		= $this->Name;
 			$this['Water']		= $this->Water;
 			$this['Cup']		= $this->Cup;
 		}
 
 		$this->SetFunction('Produce', 'doProduce');
-		self::CallParent('doSuperChain');
+
 	}
 
 	public function doSuperChain()
 	{
 		print __CLASS__.'::SuperChain('.var_export(func_get_args(), true).")\n";
 
 		parent::doSuperChain(__CLASS__);
 	}
 }
 
 
 class SugarCube extends Decorator
 {
 	public function __construct(Component $Parent)
 	{
 		parent::__construct($Parent);
 
 		$Parent->AddDecorator(array($this, 'AddSugar'));
 
 		$this->SetFunction('SuperChain', 'doSuperChain');
 	}
 
 	public function AddSugar()
 	{
 		$this['Cup']['Spoon']	 = 1;
 		$this['Ammount']		 = @$this['Ammount'] + 1;
 		$this['Water']			-= 10;
 
-		self::CallParent('doSuperChain');
+
 	}
 
 	public function doSuperChain()
 	{
 		print __CLASS__.'::SuperChain('.var_export(func_get_args(), true).")\n";
 
 		parent::doSuperChain(__CLASS__);
 	}
 }
 
 class DoubleSugarCube extends SugarCube
 {
 	protected $old;
 
 	public function __construct(Component $Component)
 	{
 		parent::__construct($Component);
 
 		$this->old = $this->SetFunction('Produce', 'doProduce');
 
 		$this->SetFunction('SuperChain', 'doSuperChain');
 	}
 
 	public function AddSugar()
 	{
 		// Call parent class then parent object
 		$this['Cup']['Spoon']	 = 1;
 		$this['Ammount']	 	 = @$this['ammount'] + 2;
 		$this['Water']			-= 20;
 
 		printf('Adding sugar: %d%s', 2, "\n");
 	}
 
 	public function doProduce()
 	{
 		print "\nI have take over Produce!\n";
 		print "But I'm a nice guy so I'll call my parent\n\n";
 
 		// Call parent objects function
-		self::CallParent('doSuperChain');
+
 	}
 
 	public function doSuperChain()
 	{
 		static $count = 0;
 
 		print __CLASS__.'::SuperChain('.var_export(func_get_args(), true).")\n";
 
 		parent::doSuperChain(__CLASS__);
 	}
 }
 
 
 $Sugar = 1;
 $DoubleSugar = 1;
 
 $Cofee = new SimpleCofee();
 $Tea   = new SimpleTea();
 
 $Cofee->Produce();
 $Tea->Produce();
 
 print "\n============\n\n";
 
 if($Sugar)
 {
 	new SugarCube($Cofee);
 	$Cofee->Produce();
 	new SugarCube($Cofee);
 	$Cofee->Produce();
 }
 
 if($DoubleSugar)
 {
 	new DoubleSugarCube($Tea);
 	$Tea->Produce();
 	new DoubleSugarCube($Tea);
 	$Tea->Produce();
 }
 
 print "\n============\n\n";
 
 $Tea->SuperChain('test');