Witam, napisałem sobie klasę SQL do obsługi bazy. Nic nadzwyczajnego. Mam też dwie inne klasy: Extenstion (ładuje mi klasy rozszerzeń) i klasę Auth (klasa z autoryzacja uzytkownika). Na czym polega problem? Nie umiem się w klasie Auth odwołać do bazy danych. Podam kod i może będzie jaśniej:

Część kalsy SQL

[PHP] pobierz, plaintext 
<?php
public static function init( $host, $user, $pass, $dbname, $p = false )
	{
		if ( !self::$instance instanceof self )
		{
			self::$instance = new Wolf_MySQL_DBE( $host, $user, $pass, $dbname, $p = false );
		}
		return self::$instance;
	}
?>
[PHP] pobierz, plaintext 

Klasa extension

[PHP] pobierz, plaintext 
<?php
class Extension
{
	public $db;
	public $auth;
 
	public function __construct()
	{
		$this->db = SQL::init( 'localhost', 'root', '', 'test', false );
		$this->auth = AUTH::init();
	}
}
?>
[PHP] pobierz, plaintext 

i klasa AUTH (jej część)

[PHP] pobierz, plaintext 
<?php
class AUTH extends Extension {
	private static $instance;
 
	public static function init()
	{
		if ( !self::$instance instanceof self )
		{
			self::$instance = new AUTH();
		}
		return self::$instance;
	}
	function login( $login, $pass )
	{
		echo "<p>------------------------------------------------------</p>";
 
		echo "<p>------------------------------------------------------</p>";
	}
}
?>
[PHP] pobierz, plaintext 

Nie wiem w jaki sposób odwołać sie w metodzie login do bazy danych. Próbowałem poprzez $this->db->setSql(), przez $db->setSql(), setSql i nic, dostaję komunikat

Co robię źle? Widziałem podobny mechanizm u kumpla, ale on siedzi w wojsku i nie ma mi jak wyjaśnić co zrobił :/

parent::NazwaFunkcjiRodzica albo Extension::NazwaFunkcjiRodzica

ale tutaj nie widze czegos takiego jak: set_sql()

Nie ma setSql bo nie wkleiłem Musiałbym całą klasę SQL wkleić

dam jeszcze raz co mam i co chcę osiągnąć:

[PHP] pobierz, plaintext 
<?php
class SQL
{
	function init()
	{ utworzenie instancji klasy SQL }
	function setSql()
	{  }
}
 
class Auth extends Extension
{
	function init()
	{ utworzenie instancji klasy auth }
	function login()
	{
		 //tutaj chciałbym by można było korzystać z metod klasy SQL w taki sposób
		$this->db->setSQL();
	}
}
 
class Extension
{
	public $db;
	public $auth;
 
	public function __construct()
	{
		$this->db = Wolf_MySQL_DBE::init( 'localhost', 'root', '', 'test', false );
		$this->auth = AUTH::init();
	}
}
 
// tworze obiekt na którym wykonuje moje metody
$d = new Extension;
$d->auth->login();
$d->db->setSQL();
?>
[PHP] pobierz, plaintext 

Jak zrobić, by można było w taki sposób odwoływać się do tych rzeczy? Kumpel ma tak, że sobie utworzył jeden obiekt $strona i na nim wykonuje metody np:

[PHP] pobierz, plaintext 
<?php
$strona = new Extension;
$strona->auth->login();
if ($strona->auth->isLogged)
{
	echo 'zalogowany';
	$strona->db->setSQL();
	echo $strona->db->getRows();
}
else
{
	echo 'Zaloguj sie';
}
?>
[PHP] pobierz, plaintext 

Coś takiego chciałbym osiągnąć, bo uważam, ze nieźle to działa, sprawdza się i przyzwyczaiłem się do tego, ale muszę dopisać kilka swoich rzeczy, a nie wiem jak je później wykorzystać w jego mechaniźmie. W moim własnym, też by mi się przydało coś takiego.

--------
-EDIT-
--------
Zauważyłem, że jak dam w klasie AUTH w konstruktorze linijkę

[PHP] pobierz, plaintext 
<?php
$this->db = SQL::getInstance();
?>
[PHP] pobierz, plaintext 

to wtedy działa idealnie, ale nie moge przecież w każdej klasie pobierać instancji każdej klasy, od tego chce mieć klasę extension w której mi to będzie robił automat.

Ja proponuję takie rozwiązanie:

[PHP] pobierz, plaintext 
<?php
 
	class SQL
	{
 
		public function __construct()
		{
			echo '<b> SQL::__construct() </b><br />';
		}
 
		public function connect( $dbhost, $dbuser, $dbpass, $dbname, $persistent=true )
		{
			echo '<b> SQL::connect() </b><br />';
		}
 
		public function setSQL()
		{
			echo '<b> SQL::setSQL() </b><br />';
		}
 
	}
 
 
	class Auth
	{
 
		public function __construct() 
		{ 
			echo '<b> Auth::__construct() </b><br />';
		}
 
		public function login()
		{
			echo '<b> Auth::login() </b><br />';
 
			// Wykonujemy zapytanie
			$ext = new Extension();
			$ext->SQL->setSQL();
		}
 
	}
 
 
 
	class Extension
	{
		private static $objects = array();
 
 
		public function __construct() { }
 
		public function __get( $object )
		{
			$object = strtolower( $object );
 
 
			// Sprawdzamy, czy dana klasa istnieje 
			// i czy jej obiekt znajduje się już w tabeli Extension::$objects
			// Jeśli nie, to go tworzymy
			if( !isset( self::$objects[$object] ) ) 
			{
				if( !class_exists( $object, true ) ) {
					throw new Exception( 'Class "' . htmlspecialchars( $object, ENT_QUOTES, 'UTF-8' ) . '" not exists' );
				}
 
				self::$objects[$object] = new $object();
			}
 
 
			// Zwracamy obiekt
			return self::$objects[$object];
		}
 
	}
 
 
 
	$ext = new Extension();
 
	// Łączymy się z bazą danych
	$ext->SQL->connect( 'localhost', 'root', '', 'test', false );
	// Wywołujemy metodę login()
	$ext->Auth->login();
 
?>
[PHP] pobierz, plaintext 

Obiekty przechowywane są w zmiennej statycznej klasy Extension, więc nie są one gubione przy tworzeniu nowych obiektów tej klasy.
Mankamenty:
- Klasa Extension nie może mieć zmiennej publicznej o nazwie identycznej, jak nazwa którejś z twoich klas (chociaż nie wiem czy będziesz potrzebował jakiekolwiek zmienne publiczne w klasie Extension)
- Brak możliwości przekazania parametrów do konstruktora wywoływanej klasy. Można to uzyskać przez zamianę magicznej metody __get() na magiczną metodę __call(), a następnie obiekty tworzyć przy użyciu eval" title="Zobacz w manualu PHP" target="_manual - jednak takie rozwiązanie mi się osobiście nie podoba.

Kicok, dziękuję ślicznie. Właśnie o coś takiego mi chodziło.

Ja siedziałem też nad problemem trochę w sobotę i znalazłem takie rozwiązanie:

[PHP] pobierz, plaintext 
<?php
 
class a
{
	public static function & getInstance()
	{
		static $instance;
		if ( !isset( $instance ) )
		{
			$instance = new a;
		}
		return $instance;
	}
 
	public function fca()
	{
		echo 'klasa a';
	}
}
 
class c extends b
{
	public static function & getInstance()
	{
		static $instance;
		if ( !isset( $instance ) )
		{
			$instance = new c;
		}
		return $instance;
	}
 
	public function fcc()
	{
		echo 'klasa c <br />';
		$this->a->fca();
 
	}
}
 
class b
{
	public $c;
	public $a;
 
	public static function & getInstance()
	{
		static $instance;
		if ( !isset( $instance ) )
		{
			$instance = new b;
		}
		return $instance;
	}
 
	public function __construct()
	{
		$this->a = a::getInstance();
	}
 
	public function pokaz()
	{
		echo '<pre>';
		print_r($this);
		echo '</pre>';
	}
}
 
$db = c::getInstance();
 
/* @var $db c */
$db->pokaz();
$db->a->fca();
$db->fcc();
 
?>
[PHP] pobierz, plaintext 

------
EDIT
------

Po krótkich testach doszedłem do wniosku, że Twoje podejście jest bardziej uniwersalne od mojego. Wystarczy, że utworzę sobie swój nowy obiekt typy Extension i już mam dostęp do wszystkich rozszerzeń jakie potrzebuję. A wiesz może jak napisać by ZEND obsługiwał podpowiedzi dla takiej składni?