Newsgroup: it.comp.lang.perl
Titolo: Salvare un oggetto in un hash

Ciao,
mi sto chiedendo perchè questa serie di istruzioni non funzionano rispetto
alla successiva:
$data->{io} = new IO::Handle;
$data->{io}->fdopen(fileno($sock),"w");
$data->{io}->print("$pacchetto"); #Non da errori ma non spedisce i dati
Questa dopo funziona:
$io = new IO::Handle;
$io ->fdopen(fileno($sock),"w");
$io->print("$pacchetto"); #Spedisce perfettamente i dati.
E' un rompicapo assurdo.
Forse voi lo sapete.
Grazie, ciao

 
prova con:
$data{'io'} = new IO::Handle;
 
$data{'io'}->fdopen(fileno($sock),"w");
 
$data{'io'}->print("$pacchetto"); #Non da errori ma non spedisce i dati
-- 
-- Marco Allegretti --
http://www.shishii.com

Ciao shishii,
non posso usare quel metodo perchè nel mio caso quello che uso è un oggetto
di un package. Per ogni nuovo oggetto che creo devo anche creare un oggetto
Handle e quindi devo creare un hash anonimo. Cioè, io mi sono fatto un mio
package e per ogni nuova connessione che ricevo creo un mio nuovo oggetto
SLIB e all'interno crea crea lui un nuovo oggetto Handle.
sub new {
 my ($name, $sock,$tipo,$chiave)=@_;
 my $data={};
 my $io = new IO::Handle;
 $io->fdopen(fileno($sock),"w");
 $data->{io}=$io;
 $data->{'sock'}=$sock;
 $data->{'stato'}=1;
 $data->{'buf'}="";
 $data->{'crc'}="";
 $data->{'tipo'}=$tipo;
 $data->{'compress'}=0;
 $data->{'chiave'}=$chiave if $chiave;
 $data->{'length'}=0;
 $data->{'richiesta'}=0;
 $data->{'client_info'}={};
 $data->{'header'}="";
 bless($data,"SLIB");
 return $data;
}
Ho provato anche a fare in questo modo.
QUesto lo scrivevo quando creavo il mio oggetto:
my $io = new IO::Handle;
$io->fdopen(fileno($sock),"w");
$data->{io}=\$io;
Quando mi serviva usavo uno dei due metodi:
my $io=$data->{io};
$io=$$io;
$io->print();
oppure
($data->{io})->print();
Ovviamente non funzionava nessuno dei due.
Questa cosa mi da un po' noia...uffa
Grazie lo stesso shishii,

LordSaga640 ha scritto:

Prova a costruire più correttamente l'oggetto:
sub new {
 my $first = shift;
 my $class = ref($first) || $first;
 my ($name, $sock,$tipo,$chiave)=@_;
 my $data={};
# a occhio non mi pare una grande idea inserire 
# nel costruttore la creazione del socket comunque...
 my $io = new IO::Handle;
 $io->fdopen(fileno($sock),"w");
 $data->{io}=$io;
 $data->{'sock'}=$sock;
 $data->{'stato'}=1;
 $data->{'buf'}="";
 $data->{'crc'}="";
 $data->{'tipo'}=$tipo;
 $data->{'compress'}=0;
 $data->{'chiave'}=$chiave if $chiave;
 $data->{'length'}=0;
 $data->{'richiesta'}=0;
 $data->{'client_info'}={};
 $data->{'header'}="";
 bless($data,$class);
 return $data;


  $data->{io}=$io;
non dovresti applicare l'operatore -> a $data in questo punto, poichè $data
non è ancora stato benedetto e qui è un semplice riferimento ad hash. 
Dovresti scrivere invece:
 ${$data}{io} = $io;
oppure al limite:
 $$data{io} = $io
L'operatore -> lo puoi applicare dopo il bless.

 ha scritto nel
messaggio news:eO4Wc.170846$5D1.8...@news4.tin.it...


 L'operatore -> lo puoi applicare dopo il bless.
L'operatore arrow ha comportamenti differenti a seconda della 
natura del suo operando di destra. Confronta il paragrafo 
"The Arrow Operator" in perlop. 
$data->{ io } e` una scrittura corretta, se $data e` una hash
reference. Secondo me, inoltre, e` persino piu` chiara di
$$data{io} e simili.
ciao,
S.
-- 
Stefano Rodighiero      |  
http://larsen.perlmonk.org
mailto:
lar...@perl.it
   |  
http://www.perl.it

 > non č ancora stato benedetto e qui č un semplice riferimento ad hash.


 
Il problema non è dove lo stai cercando. Usare un reference contenuto in uno
slot di un hash non comporta, di per sé, differenze rispetto ad usare una
variabile. Evidentemente, se i comportamenti sono diversi, le condizioni
differeriscono per altri aspetti. Non è chiaro, inoltre, cosa intendi
quando dici "Non da errori ma non spedisce i dati". Come controlli
eventuali errori? Come riscontri che i dati non sono spediti? 
Sarebbe di aiuto se preparassi un esempio minimo e eseguibile di codice che
consentisse di riprodurre il problema.
Max

 Max
Ciao, sì', in effetti non ho parlato molto.
Allora, prima di dichiarare la mia sconfitta ho fatto un po' di prove.
In pratica io quando creo l'oggetto SLIB, nella funzione NEW creo anche un
oggetto IO::handle che poi uso in seguito in altre funzioni. L'ggetto
IO::Handle creato serve per gestire uno socket, per inviare i dati.
QUando nell'altra funzione della mia classe vado a fare la print
dell'oggetto IO::Handle, questa non funziona, non spedisce i dati perchè io
non li ricevo, mentre funziona se io uso la SEND.
Questa è la funzione che richiede l'oggetto handle:
sub name {
 my ($data,$pacchetto)=@_;
 my $rin;
 my $sock =$data->{sock};
 incapsula(\$pacchetto);
    vec($rin,fileno($sock),1) = 1;
 $data->{daspedire}.=$pacchetto;
 while (select(undef,$rin,$rin,0)) {
  last unless $pacchetto=substr($data->{daspedire},0,3500,"");
   $data->{io}->print("$pacchetto");
 }
}
A quel punto mi sono chiesto perchè non funzionasse, così ho provato a fare
un test creando l'oggetto all'interno della funziona NAME.
E' stata una sorpresa sapere che i dati venivano inviati solo se creavo
l'oggetto e lo salvavo in uno scalare normale.
Ossia questa funziona (ricevo perfettamente i dati):
 my $io = new IO::Handle;
 $io->fdopen(fileno($sock),"w");
 $io->print("dati");
Ma queste istruzioni non funzionano ma non danno neanche errore. Se provo a
stampare sullo schermo $data->{io}l'oggetto è effettivamente creato, eppure
i dati non arrivano.
$data->{io} = new IO::Handle;
$data->{io}->fdopen(fileno($sock),"w");
$data->{io}->print("dati");
Cioè, è stranissimo, non me lo spiego. :°°(