Witam,
piszę mały silnik dla swojej aplikacji. Chcę go oprzeć o wzorzec MVC. Chciałbym zrobić ładowanie modelu podobnie jak w kohanie, tylko jest jeden problem.
Mam klase loader, metode model.

[PHP] pobierz, plaintext 
public function model( $name) {
 
			//require
			require MODELS_PATH . $name . '.php';
			$this -> $name = new $name;
		}
[PHP] pobierz, plaintext 

gdy w kontrolerze dziedzicze klase loader, to przy tworzeniu modelu pole tworzy się w klasie loader, więc z kontrolera nie mam bezpośredniego dostępu $this -> pole.
Jak można by to inaczej zrobić? Jestem otwarty na propozycje

Jeśli dobrze zrozumiałem, to chcesz wywołać metodę klasy bazowej w klasie wyprowadzonej, rozwiązanie jest proste: parent

sory, troche w błąd wprowadziłem. nie chce dziedziczyć klasy, tylko w kontrolerze ją wywołać $this -> load = new loader;
i potem ładowac modele $this -> load -> model('model'); i chce by mi pole modelu tworzyło w kontrolerze, a nie w loaderze

Magiczne setter i getter powinny wystarczyć.
ps. nie wiem, jak to dokładnie wygląda w Kohanie.

nie wiem jak to można zastosować, szczerze mówiąc pierwszy raz sie z takim czymś spotykam. Jakaś mała podpowiedź?

http://www.php.net/manual/en/language.oop5...loading.members
Pokaż jeszcze swój kod, bo nie mam pewności czy rozmawiamy o tym samym.

nie rozumiem jak chcesz to niby zastosować?

Właśnie dlatego prosiłem o pokazanie kodu, bo nie mam pewności czy się rozumiemy. Zastosowanie magicznego settera w kontrolerze można byłoby połączyć z tablicą przechowującą modele, wystarczyłoby zwracać instancę tworzonego modelu w metodzie load klasy loader (jeśli Cię dobrze zrozumiałem). Zresztą zerknij jeszcze tu

[PHP] pobierz, plaintext 
<?php
	//loader on controller
	class loader {
 
		/**
		 * method view
		 *
		 */
 
		public function view( $file, $array = true) {
 
 
			//if second argument is array
			if( is_array( $array)) {
 
				foreach( $array as $item => $val) {
 
					//this is vars
					$$item = $val;
				}
			}
 
			//display view
			include VIEWS_PATH . $file . '.php';
		}
 
		/**
		 * method model
		 *
		 */
 
		public function model( $name) {
 
			//require
			require MODELS_PATH . $name . '.php';
			$this -> $name = new $name;
		}
	}
 
	class controller {
 
		public function __construct() {
 
			$this -> load = new loader;
 
			$this -> load -> model('test');
 
			echo $this -> test -> oki();
		}
	}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class test {
	public $test = 'test';
	public function Test() {
		return 'test method';
	}
}
/////////////
	//loader on controller
	class loader {
 
		/**
		 * method view
		 *
		 */
 
		public function view( $file, $array = true) {
 
 
			//if second argument is array
			if( is_array( $array)) {
 
				foreach( $array as $item => $val) {
 
					//this is vars
					$$item = $val;
				}
			}
 
			//display view
			include VIEWS_PATH . $file . '.php';
		}
 
		/**
		 * method model
		 *
		 */
 
		public function model( $name) {
 
			//require
			require MODELS_PATH . '.' . $name . '.php';
			//$this -> $name = new $name;
			return new $name;
		}
	}
 
	class controller {
 
		private $_models = array();
		protected $load = null;
 
		public function __construct() {
 
			$this -> load = new loader;
 
			$this ->_models[] = $this->load -> model('test');
 
			echo $this ->_models[0] ->Test();
		}
}
 
$c = new controller();
[PHP] pobierz, plaintext 

nie działa:

Notice: Undefined property: controller::$test in C:\xampp\htdocs\tomato\system\libraries\controller.php on line 68

Fatal error: Call to a member function oki() on a non-object in C:\xampp\htdocs\tomato\system\libraries\controller.php on line 59


nie ma jak.
napisze w konstruktorze, to zanim dodam model to mi już tablice spróbuje zapełni.
dam w destruktorze, to już mi będą dane zbędne :/

Zedytowałem swojego poprzedniego posta zmieniając w ogóle koncepcję.

działa, ale nie tak jak powinno. Chciałem przy ładowaniu modelu stworzyć też pole dla niego :/

Cieszę się, że udało się dobrnąć do tego stwierdzenia W tym momencie należałoby zaimplementować proponowane przeze mnie magiczne metody: setter i getter, np.

[PHP] pobierz, plaintext 
class controller {
 
		private $_models = array();
		protected $load = null;
 
		public function __construct() {
 
			$this -> load = new loader;
 
			$this ->_models['test'] = $this->load -> model('test');
 
			echo $this ->_models['test'] ->Test();
		}
 
		public function __set($prop_name,$prop_value) {
			$this->$prop_name = $prop_value;
		}
 
		public function __get($model_name) {
			return $this->_models[$model_name];
		}
}
 
$c = new controller();
print_r($c->test);
echo $c->test->Test();
[PHP] pobierz, plaintext 

sęk w tym, że chce się do tego zwracać w konstruktorze w klasie, a nie poza nią.
echo $this -> test -> oki(); nie działa

Myślałem, że już się sam domyślisz o co chodzi:

[PHP] pobierz, plaintext 
class test {
	public $test = 'test';
	public function Test() {
		return 'test method';
	}
}
 
class controller {
 
		private $_models = array();
		protected $load = null;
 
		public function __construct() {
 
			$this -> load = new loader;
 
			$this ->_models['test'] = $this->load -> model('test');
 
			//echo $this ->_models['test'] ->Test();
                        // Proszę bardzo, magiczny getter zadziałał:
			echo $this->test->Test();
		}
 
		public function getModels() {
			return $this->_models;
		}
 
		public function __set($prop_name,$prop_value) {
			$this->$prop_name = $prop_value;
		}
 
		public function __get($model_name) {
			return $this->_models[$model_name];
		}
}
 
$c = new controller();
[PHP] pobierz, plaintext 

Dzięki staruszku, w nocy się nie domyślam niczego także wybacz. Pewnie, ze działa.

Staruszku? No dzięki
W ogóle proponuję coś takiego:

[PHP] pobierz, plaintext 
class test {
	public $test = 'test';
	public function Test() {
		return 'test method';
	}
}
class test2 {
	public $test = 'test2';
	public function Test2() {
		return 'test method2';
	}
}
/////////////
	//loader on controller
	class loader {
 
		/**
		 * method view
		 *
		 */
 
		public function view( $file, $array = true) {
 
 
			//if second argument is array
			if( is_array( $array)) {
 
				foreach( $array as $item => $val) {
 
					//this is vars
					$$item = $val;
				}
			}
 
			//display view
			include VIEWS_PATH . $file . '.php';
		}
 
		/**
		 * method model
		 *
		 */
 
		public function model( $name) {
 
			//require
			require MODELS_PATH . '.' . $name . '.php';
			//$this -> $name = new $name;
			return new $name;
		}
	}
 
	class controller {
 
		private $_models = array();
		protected $load = null;
 
		public function __construct() {
 
			$this -> load = new loader;
			$this->_loadModels(array('test','test2'));
			echo $this->test->Test();
			echo $this->test2->Test2();
		}
 
		public function __set($prop_name, $prop_value) {
			$this->_models[$prop_name] = $prop_value;
			//$prop_name = $prop_value;
		}
 
		public function __get($model_name) {
			return $this->_models[$model_name];
		}
 
		private function _loadModels(array $models) {
			foreach($models as $m) {
				$this->_models[$m] = $this->load->model($m);
			}
		}
}
 
$c = new controller();
[PHP] pobierz, plaintext 

czekaj, czekaj, bo o jednej rzeczy zapomnieliśmy

[PHP] pobierz, plaintext 
$this ->_models['test'] = $this->load -> model('test');
[PHP] pobierz, plaintext 

jak zrobić, bym nie musiał dawać tego $this ->_models['test'].
bo jak chce operować na metodach klasy, to mode dać load model i niech mi tworzy pole w klasie, co nie? :]

O niczym nie zapomnieliśmy zerknij na metodę _loadModels oraz konstruktor Tylko tak dla porządku to powinno to zostać przerzucone do samego loadera dla utrzymania jakichś podstaw logiki, no ale to już sobie poradzisz i posprzątasz w tych klasach. A tak już zupełnie profesjonalnie to powinien być dobrze napisany autoloader z jakimiś przejrzystymi regułami, który umożliwiałby lazy loading modeli.

otóż to, chciałem ładować $this -> load -> model :] a nie $this -> loadmodel

edit:
jako iż rano włączam myślenie, tak więc poradziłem sobie. tablice dałem w klasie load w metodzie model.

A nie lepiej przekazywać od razu instancje klas modelu?

Zadam może niewłaściwe pytanie, ale... dlaczego po prostu nie użyć autoloaderów? Ja tam wolę pisać po prostu

[PHP] pobierz, plaintext 
$jakisModel = new jakisModel();
[PHP] pobierz, plaintext 

a reszta robi się automagicznie sama, włącznie z require i podobnymi...