Datencontainer für einen Join

[T-Rex]

Hey T-Rex du doofian, dass ist doch ganz einfach :D.
Nagut spaß bei Seite.
Wie gesagt denke ich ist die Lösung die Mehrfachvererbung. Deshalb habe ich auf der Schiene mal Recherchiert und habe einen netten Eintrag irgendwo in einem englischen Forum gefunden. Den Code dort habe ich ein wenig angepasst und automatisiert. Als erstes hat man eine Klasse welche die Mehrfachvererbung simulieren soll (damit ich mich leichter tue beim erklären möchte ich davon ausgehen dass es eine echte Mehrfachvererbung ist).

	class cMultiInharitance  
	{  
		private $arMethods    = array();  
		private $arInstances  = array();  
		private $intId        = 0;  
		  
		public function __construct($arClasses)  
		{  
			if(!is_array($arClasses))  
			{  
				return false;  
			}  
  
			foreach ( $arClasses as $strClassName )  
			{  
				if(class_exists($strClassName))  
				{  
					$this->arInstances[ $strClassName ] = new $strClassName();  
					//--- Per Reflektion alle Public Methoden raussuchen  
					$objReflection = new ReflectionClass( $strClassName );  
					$arPublicProp = $objReflection->getMethods( ReflectionProperty::IS_PUBLIC );  
					foreach($arPublicProp as $objProp)  
					{  
						if( isset($this->arMethods[$objProp->getName()]) )  
						{  
							//--- überschreiben der Methode  
						}  
						$this->arMethods[ $objProp->getName() ] = $strClassName;  
					}  
				}  
			}  
		}  
	  
		public function __call($strMethod, $arArguments)  
		{  
			if( !isset( $this->arMethods[$strMethod] ) )  
			{  
				return;  
			}  
			  
			$objClass = $this->arInstances[ $this->arMethods[$strMethod] ];  
			return call_user_func_array(array($objClass,$strMethod), $arArguments);  
		}		  
	}  

zur Erklärung komm ich gleich.
Diese Klasse wird einer anderen Klasse, welche die Mehrfachvererbung erhalten soll vererbt.

	class cMultiClass extends cMultiInharitance  
	{  
		public function __construct()  
		{  
			$arClass = array();  
			$arClass[] = "cClassA";  
			$arClass[] = "cClassB";  
			parent::__construct($arClass);  
		}  
	}  

Die Klassen cClassA und cClassB sind hier nur aus Demonstrationsgründen genannt.
class cMultiClass extends cMultiInharitance wäre das gleiche wie class cMultiClass extends cClassA extends cClassB.
Beim initialisieren übergibt man ein Array mit den Klassen welche man Vererben möchte. Diese werden dann in der cMultiInharitance Initialisiert, per Reflektion auseinander genommen und anhand ihrer Public Methods untersucht. Diese werden dann in einem Array gespeichert.
Ruft man eine Methode von cMultiClass auf, so wird diese ganz einfach wie gewöhnlich aufgerufen. Ruft man eine Methode auf die nicht in cMultiClass implementiert ist, so wird die __call Methode der cMultiInharitance Klasse aufgerufen. Diese wiederum guckt ob sie eine entsprechende Methode der Unterklassen gespeichert hat. Wenn ja wird der aufruf an diese weitergeleiet.

Das Code dort oben ist auf meine Bedürfnisse angepasst. Es gibt einige enerell Schwachstellen. Es werden z.B. keine Namespaces behandelt. Zudem könnte man eine exception werfen, wenn 2 gleichenamige Methoden in Unterklassen existieren. Außerdem wird gleich mit der Auswertung der Unterklassen angefangen. Dies könnte man verzögert ausführen, wenn man "sicher" ist dass die Klasse angesprochen wird.

Was zudem nicht funktionieren dürfte ist eine Mehrfachvererbung einer anderen Klasse zu geben. Also:

class cMultiClass extends cMultiInharitance  
{  
}  
  
class cMultiMultiClass extends cMultiInharitance  
{  
	public function __construct()  
	{  
		$arClass = array();  
		$arClass[] = "cMultiClass";  
		parent::__construct($arClass);  
	}  
}

Aber das Konstrukt hab ich nicht getestet, da ich es nicht brauche.
Ich bin mir zudem sicher das einige viele andere Dinge ebenfalls nicht funktionieren. Wie gesagt hab egoistischer Weise nur mein Problem mit eine wenig Magie ;) gelöst.

Danke an alle Hinweisgeber.
Hoffe ich hab die Sachen ein bischen Verständlich beschrieben.

Gruß
T-Rex