Newsgroup: it.comp.www.php
Titolo: Sostituto delle variabili globali

Leggevo nel newsgroup che le variabili globali sono "il male".
Io ho una applicazione piuttosto complessa, composta da una
infinitï¿œ di classi che devono operare tutte su un oggetto
in comune.
Ad esempio:
---
$pippo = new Oggetto();
function test() {
    $pippo->aggiungiItem($PROVA::miaClasse->tipoOggetto('nome');
}
---
In pratica creo l'oggetto generico con "new Oggetto".
Poi, in vari punti del programma, devo richiamare determinati
metodi dell'oggetto "pippo", come ad esempio "aggiungiItem"
il quale assumerï¿œ un valore pari al valore ritornato dal
metodo "tipoOggetto" richiamato in maniera dinamica da
"PROVA::miaClasse".
Facendo "PROVA::miaClasse->tipoOggetto" dovrei riuscire a
richiamare il metodo "tipoOggetto" della classe "miaClasse"
senza obbligatoriamente creare l'oggetto con "$PIPPO = new miaClasse".
In pratica istanzio, eseguo il metodo e distruggo tutto su una riga.
Giusto?
Ma a parte questo, se le variabili globali sono "il male" e da evitare,
io come accedo al super oggetto $pippo?
Non posso usare le sessioni in questo modo:
$_SESSION['pippo'] = new Oggetto();
perchï¿œ il codice dovrï¿œ essere eseguito anche a linea di comando sul
server e l'array $_SESSION non puï¿œ funzionare (niente cookie).
In questo caso l'array super globale $GLOBALS
non puï¿œ essere una soluzione?

 in comune.
Premesso che ho sonno, molto sonno, vedo due possibili alternative:
1) singleton
2) registry
google->da quella parte :)
Notte.
-- 
*** Linux user # 198661 ---_ ICQ 33500725 ***
    ***  Home  
http://www.kailed.net
  ***
        ***  Powered by openSUSE  ***

 
Forse ho omesso una parte importante.
Io ho un oggetto XML, creato con SimpleXML.
Questo oggetto deve essere manipolato da più parti del programma.
Ad esempio, quando viene istanziata la classe "Root" io devo creare
un oggetto XML vuoto.
Poi istanzio la classe "Scaffale" e automaticamente il constructor di
quella classe deve creare un child nel record XML con l'addChild di
SimpleXML.
Poi istanzio la classe "Libro" ed il constructor deve creare un child
di nome Libro, e così via.
In pratica un albero:
Root
  |--Scaffale
    |--Libro
I nodi sono creati vuoti in fase di creazione oggetto, poi ciascun
oggetto avrà il metodo "addElement" da me creato che si occuperà di
creare degli elementi all'interno del nodo attualmente attivo.
In pratica ho bisogno di avere, a monte di tutto, l'oggetto XML e di
potervi accedere mantenendone inalterato lo stato.
Ad esempio se l'ultima classe istanziata è stata quella dello Scaffale,
quando istanzierò la classe "Libro", l'elemento XML Libro dovrà essere
creato dentro lo Scaffale, perchè io mi trovavo li con il "puntatore".
In che modo si può fare?
Potrei benissimo accedere ai nodi XML con il nome, ma preferirei fare
qualche cosa di dinamico....

 In che modo si può fare?
Uhmm a me sembra un po' incasinato.
IMHO, dovresti avere gli oggetti $scaffale e $libro e un controller che 
si uccupi di gestire i due oggetti.
Oppure, salvi l'oggetto $scaffale in un registry e dentro $libro 
recuperi $scaffale e ci fai quello che ci devi fare.
O ancora se applicabile il pattern singleton, dentro $libro recuperi 
l'istanza $scaffale.
In pratica:
nel primo caso avrai una cosa tipo:
$scaffale = new scaffale();
registry::set('scaffale', $scaffale);
e dentro libro:
$scaffale = registry::get('scaffale');
$scaffale->add($this->libro());
Nel secondo caso:
$scaffale = scaffale::getInstance();
e dentro libro, la stessa cosa.
Se poi alla fine hai una classe "superiore", diciamo "libreria":
$libreria->add($scaffale->getScaffale());
Poi magari non ho capito nulla e quanto detto non si applica affatto e/o 
ci sono metodi migliori :)
Magari aspetta qualche altra opinione.
Ciao.


 Ciao.
Per il momento ho risolto con un singleton.
Faccio un po di prove poi eventualmente espongo la
soluzione che ho adottato.
-- 
Non tocca a noi dominare tutte le maree del mondo,
il nostro compito è di fare il possibile per la
salvezza degli anni nei quali viviamo,
sradicando il male dai campi che conosciamo.

 Ciao.
Diciamo pure che non ci sto cavando le zampe.
Faccio prima, mi sa, a fare dei template XML con smarty
e sostituire le variabili.
Non devo alterare il database, devo connettermi a delle
API remote inviando degli XML.
Avrei preferito gestire interamente le API, ma la faccenda
si complica non poco, credo che facendo dei template si
faccia prima.


 API remote inviando degli XML.
Non so che dirti. Come detto nell'altro post, mia pare che ci sia un po' 
di casino.
Tu hai degli oggetti ($Libro, $scaffale, etc, etc) e con questi devi 
interagire.
La classe $libro dovrebbe restituirti il pezzo di XML relativo al libro:
in pseudo XML
<libro>
 <titolo>
 <autore>
 <etc>
</libro>
La classe $scaffale prenderà i dati da $libro, costruendoci intorno la 
propria parte di XML:
<scaffali>
 <scaffale uno>
  XML generato da $libro
 </scaffale uno>
</scaffali>
A questo punto prendi da $scaffale l'XML e lo passi/invii a chi ti pare.
Il tutto si potrebbe tradurre in qualcosa tipo:
$scaffale = new Scaffale();
$libro = new Libri();
$scaffale->add($libro->getLibri();
$xml = $scaffale->getXml();
se hai una classe superiore, stesso discorso:
$libreria = new Libreria();
$libreria->add($scaffale->getScaffali());
$xml = $libreria->getXml();
Da valutare:
1) lavorare con degli array e generare l'XML solo come ultimo passaggio 
(IMHO più pratico)
1bis) puoi comunque chiedere a $libro/$scaffale di restituirti un 
oggetto, basta fare il casting dell'array
2) se avere un'unica classe/oggetto per scaffali e libri o avere dei 
singoli oggetti (uno per ogni scaffale/libro)
Quello che vuoi fare tu mi sembra relativamente semplice, detto da uno 
che è tutt'altro che esperto :)


 La classe $libro dovrebbe restituirti il pezzo di XML relativo al libro:
Io devo interagire con un server remoto mediante API XML.
Ad esempio, per creare un libro, devo inviare una API così:
<API>
  <Scaffale>
   <Libro>
    <Titolo>Ciao</Titolo>
   </Libro>
  <Scaffale>
</API>
Ovviamente, prima devo fare il login:
<API>
  <Login>
   <User>ddddd</User>
  </Login>
</API>
Pensavo di salvere tutti i template XML e sostituire
le variabili tramite smarty, così da php devo fare solo
dei replace (grazie a smarty) e sparare il testo al server.
Quindi una classe primaria di nome "Servizio" che mi
gestirà i comandi base come Login/Logut ed una classe
per ogni operazione.
Esempio, nel caso volessi aggiungere un libro:
$SERVIZIO::Servizio->login();
$Libro = new Libro();
$Libro->setTitle('ddddddddd');
$SERVIZIO::Servizio->run($Libro->getXML());
$SERVIZIO::Servizio->logout();
Così facendo, mi loggo, creo il libro, gli imposto il title,
carico il template (getXML) facendo il replace delle variabili
tramite Smarty (sempre tutto in getXML) e sparo l'XML con sopra
tutto il resto dei tag grazie al metodo run (il quale mette attorno
all'xml del libro tutti i tag base, come gli header XML)
Ma a sto punto conviene fare la classe Servizio?
Dato che ho i template XML forse conviene farli 'standalone'...
Faccio a mano il login ad inizio pagina, e $Libro->getXML mi ritornerà
un XML completo, senza doverlo 'incapsulare' dentro ad una base...