Singleton esteso

[andr3a]

Originariamente inviato da Razorblade
Che cos'hanno di divertente?

che utilizzano una classe con un metodo pubblico statico per ottenere lo stesso risultato di una funzione (Loader::load('MiaClasse')) e magari non sfruttano nemmeno la Reflection creando potenzialmente problemi di consistenza al codice

Originariamente inviato da Razorblade
2) Premettendo che mi sono informato abbastanza sul metodo magico __clone e sulle tecniche di clonazione di un oggetto ( shallow e deep copy ), mi piacerebbe avere una ulteriore spiegazione e magari un esempio pratico, se possibile, a proposito di questa affermazione

quale affermazione? il discorso è sulla serializzazione e deserializzazione ... il clone è per clonare

Originariamente inviato da Razorblade
3) Per implementare il pattern singleton vi è la necessità di utilizzare __callStatic?

con __callStatic puoi definire una classe singleton, e sfruttare __callStatic per avere in modo assolutamente elegante un comportamento analogo alla loader

class Singleton {
    private static $_instance = array();
    public function __callStatic($__CLASS__, array $arguments){
        if(!isset(self::_instance[$__CLASS__])){
            $class = new ReflectionClass($__CLASS__);
            self::_instance[$__CLASS__] = $class->newInstanceArgs($arguments);
        }
        return self::_instance[$__CLASS__];
    }
}
// nota, ho scritto direttamente sulla textarea
// e non ho aggiunto il controllo sul costruttore

[Razorblade]

Grazie,
con gli esempi è più chiaro il significato.
In quanto alla domanda 2, questa è la tua l'affermazione sul tuo post

if there's no magic __clone method, it does not make sense

Se non c'è il metodo magico __clone, non ha senso.

Se non c'è __clone dove?
Questo non ho capito.
Grazie
Ciao

[andr3a]

se hai una classe di tipo singleton, anche se l'istanza è private static della classe, puoi clonare quella istanza usando

$b = clone $a;

per evitare questo, devi implementare il metodo magico __clone, che è un metodo come __call, o __get o __set, e generare un errore invece di far tornare una copia dell'istanza (in pratica fai un override esplicito del metodo intrinseco __clone)

[Razorblade]

Perfetto,
finisco di leggere il tuo post e se ho altri dubbi te li posto qui

[Mackey]

Grazie a tutti!! se sei d'accordo Andr3a alla fine utilizzerò il tuo codice.

Comunque volevo chiedervi, per un neofita come me, sarebbe stato molto più bello un comportamento del genere

class A extends Singleton ......
....
...

$a1 = new A();
... ... ...
...

$a2 = new A();
ERRORE...
oppure
$a2 = &$a1;

prendetelo come pseudo-codice naturalmente

ma mi è sembrato di capire che non si può ancora fare con questa versione di php

[andr3a]

usa pure il mio codice

riguardo il resto, se il costruttore è privato, non potrai mai fare new A

mentre l'assegnazione esplicita per riferimento sarà sempre possibile poichè avrai 2 nomi che puntano alla stessa istanza di oggetto

per risolvere il primo problema, devi cambiare runtime il costruttore della classe, ma ti serve la runkit extension, che è ancora giovane.

Una volta integrata in PHP, potrai fare quello che ti pare ...

class A {
    function __construct(){
        // codice che modifica il costruttore, al primo new A, non sarà possibile riusare new A
    }
}

In JS la cosa è fattibile ..

function A(){
    if(this instanceof A)
        A = undefined;
};

var a = new A;
new A(); // error

solo per darti un'idea del concetto, che oltretutto, come approccio, mi sembra molto interessante

[Mackey]

Questo è quello che cercavo di dire...

<?php
 
class Singleton {
    private static $instanceArray = array();
 
    public function __construct() {
        $className = get_class($this);
        if(!isset(self::$instanceArray[$className]))
            self::$instanceArray[$className] = &$this;
        else
            throw new Exception("{$className} is Singleton");
    }
 
    public static function test() { /* questo metodo è da cancellare */
        print "<pre>".print_r(self::$instanceArray, true)."</pre>";
    }
}
 
class A extends Singleton {
    public $prova;
    public function setProva($newValue) {
        $this->prova = $newValue;
    }
}
 
class B extends Singleton {
 
}
 
$a = new A();
$a->setProva("Stringa da sovrascrivere");
 
$a2 = new A(); /* Questo produce un errore! */
//$a2->setProva("Stringa sovrascrivente");
 
$a->test();
//$a2->test();
 
$b = new B();
$b->test();
 
?>

mi sarebbe piaciuto che $a2 prendesse l'istanza di $a... ma $this non si può riassegnare (non è vero?)

[Mackey]

scusate ancora... allora che mi dite dell'ultimo codice?

[Razorblade]

L'ho provato, è interessante. Ma se volessi che al posto dell'eccezione le successive istanze di una classe che estende Singleton ritornassero la prima istanza?

[Mackey]

appunto... è quello che vorrei fare anch'io... ma non si può riassegnare il $this, altrimenti per assurdo avrei fatto al posto dell'Exception:

$this = &self::$instanceArray[$className];


Quello che trovo un po' sconcertante è il fatto del concetto di Singleton in se... ovvero:
a che serve impostare l'istanza per richiamare metodi che sono nativamente statici?
anche se l'istanza fosse comunque una (caricata o con il costruttore o con il load) poi comunque richiama metodi statici... tanto vale utilizzare la classe come wrapper... o sbaglio?

Comunque soluzioni al mio approccio?