Originariamente inviato da dogeht
AGGIUNGO QUESTO:
un commento sulla documentazione di php mi ha fatto riflettere. diceva piu' o meno "un linguaggio ha molti strumenti per farti raggiungere l'obiettivo. se non riesci a raggiungere un obiettivo con uno strumento, prova a cambiare strumento. se tenti di usare diversamente lo strumento, sei sulla strada sbagliata"
insomma: si vede che non devo usare due classi tipo. ma che posso fare allora?
per ora ho adottato questa soluzione:
1) ho creato le classi tipo
2) le istanze delle classi operative hanno delle proprietà che sono istanze delle classi tipo.
percui operativa 3 avrà due proprietà-istanza delle classi tipo1 e tipo2. ma ci sono delle complicazioni che vi lascio immaginare
Sperando di aver capito bene ho provato a implementare un approccio diverso al tuo problema.
Volevo fare un esempio semplice poi mi sono messo a leggere le funzioni di reflection e ho voluto provarle. 
Il tuo esempio aveva un problema di fondo anche se ci fosse stata l'eritarieta' multipla hai chiamato due proprieta' con lo stesso nome nelle due classi tipo e come avresti gestito questa cosa nelle classi figlie di entrambi ?.
prima definisco in una clase astratta i metodi di gestione dei tipi
Codice PHP:
abstract class AbsTipo {
private $numProp = 0;
private $listProp = array();
public function __construct ($str) {
$reflect = new ReflectionClass($str);
$list = $reflect->getProperties();
$this->numProp = count ($list);
foreach ($list as $prop) {
$this->listProp[] = $prop->getName();
}
}
public function issetTipo($str) {
return isSet($this->$str);
}
public function getTipo($str) {
if ($this->isSetTipo($str)) {
return $this->$str;
} else {
return null;
}
}
public function numTipi() {
return $this->numProp;
}
public function listaTipi() {
return $this->listProp;
}
}
cosi estendendo questa classe posso implementare i tipi in modo molto semplice.
Codice PHP:
class tipo1 extends AbsTipo {
public function __construct() {
parent::__construct(__CLASS__);
}
protected $prop1 = 'pippo';
protected $prop2 = 10;
}
class tipo2 extends AbsTipo {
public function __construct () {
parent::__construct(__CLASS__);
}
protected $prop1 = 'pippo2';
protected $prop3 = 100;
}
A questo punto posso implementare le classi logiche gestendo i tipi
come meglio credo
Codice PHP:
interface interOper {
public function evalTipi();
}
class operativa1 implements interOper {
private $tipo = null;
public function __construct() {
$this->tipo = new tipo1();
}
public function evalTipi() {
$output = array();
foreach ($this->tipo->listaTipi() as $key) {
$output[$key] = $this->tipo->getTipo($key);
}
return $output;
}
}
class operativa2 implements interOper {
private $tipi = array();
public function __construct() {
$this->tipi[] = new tipo1();
$this->tipi[] = new tipo2();
}
public function evalTipi() {
$output = array();
foreach ($this->tipi as $tipo) {
foreach ($tipo->listaTipi() as $key) {
if (!isset($output[$key])) { // da notare che posso gestire il nome di proprieta' uguali come meglio credo
$output[$key] = $tipo->getTipo($key);
}
}
}
return $output;
}
}
Per finire istanzio tutto
Codice PHP:
$operativa = new operativa1();
var_dump($operativa->evalTipi());
echo "
\n\n";
$operativa = new operativa2();
var_dump($operativa->evalTipi());
Spero di esserti stato utile.
Andrea
Rispondi quotando
