Newsgroup: it.comp.java
Titolo: problemi di stream

Salve,
ecco il mio problema:
ho un metodo (sviluppato da altri) che scrive una stringa su un
OutputStream.
Vorrei che questo stream diventasse un InputStream da utilizzare come
parametro
di un altro metodo.
Non sapendo come fare ho creato un file temporaneo e con lo straming da file
ho risolto tutto
(ok... fa schifo).
Speranzoso attendo una soluzione degna di questo nome
Grazie.

(ok... fa schifo).
ci sarebbero le classi java.io.PipedInputStream e java.io.PipedOutputStream
ma per usarle penso che dovresti modificare il metodo scritto da altri facendo
in modo che l'output finisca in un PipedOutputStream invece che in un OutputStream
ciao_O
http://digilander.iol.it/schiele

 
in java1.0 se non ricordo male c'erano i PipedInputStream e
PipedOutputStream. Mai usati, ma penso facessero proprio quello
che cerchi.
Credo che nelle nuove versioni siano stati sostituiti con
qualcosa tipo "PipedReader/PipedWriter" (?).
Cerca meglio nel package 
java.io
: non ho documentazione
sottomano, ma sono pronto a scommettere che si trovi tutto
ancora li` ;-)
-- 
Ciao,  |  I play Russian roulette everyday, a man's sport,
Matteo |  With a bullet called life, yeah called life, (SUGAR)

(ok... fa schifo).
Quello che chiedi non ha molto senso. Su un'output stream ci si scrive,
da un input stream si legge. Cercando di capire, puoi intendere due cose:
1) vuoi invocare il primo metodo, aspettare che termini, leggere il risultato 
   e passarlo al secondo
2) vuoi invocare il primo e secondo metodo, in modo che qualunque cosa 
   scritta dal primo venga passata al secondo in modo asincrono
Quale delle due? Dalla tua soluzione pare 1), ma non saprei.
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun

 wrote in message
news:3a911b27...@news.tiscalinet.it...


 wrote in message
news:455r69...@luke.casa.mattia...


ObjectZone - 
http://space.tin.it/computer/csadun
In alcuni casi risulta di vera utilità:
 1- un servizio di echo in rete
 2- relazionare metodi che lavorano su generici flussi OutputStream e
InputStream (ad esempio la classe Properties, ma ora non mi vengono in
mente altri casi, anche se mi ricordo di essermi scontrato più volte
con metodi di tal tipo...)
 3- fare il clone di strutture complesse di cui si vuole una deep copy
anziché una shallow copy; 
Per il punto 3- riporto un esempio molto indicativo e utile:
supponiamo di dover generare una struttura hashtable molto complessa,
con strutture dati da noi create ( e sulle quali possiamo dunque
garantire la serializzazione ), e supponiamo di voler creare un clone
perfetto di tale struttura intendendo con ciò fare una deep copy (ad
es. potremmo lavorare su grafi/alberi e voler replicare una parte di
essi ); in tal caso utilizzando le pipe è semplicissimo fare qualcosa
che altrimenti creerebbe complicazioni talvolta incredibili:
 ad esempio pensate di implementare voi un metodo di clone che faccia
una deep copy quando è possibile che esistano all'interno del gruppo
di oggetti dei riferimenti ciclici (servono molte più righe di codice
e il numero di probabili bug cresce!!).
Proprio per questo motivo nel mio esempio ho creato una hashtable 
hSrcTable di cui ho voluto creare una deep copy hDstTable con le pipe,
e inoltre , per complicare la vita, ho usato come valori della
hashtable degli oggetti con riferimenti tali da impattare a livello
bestiale sulla memoria occupata per chiunque cerchi di emulare una
deep copy senza tener conto dei riferimenti degli oggetti ( quindi non
solo i riferimenti ciclici creano problemi).
Infine, per confermare che un clone ottenuto dalla hashtable è una
shallowcopy (fatto risaputo) mentre un clone ottenuto con le pipe è
una deep copy, ho cambiato il valore "iValue" di un oggetto della
hashtable originaria, e ovviamente solo la copia con pipe non ha avuto
ripercussioni (inoltre la stampa fa anche uso di riferimenti vari per
dimostrare come gli stessi siano preservati)
import java.io.*;
import java.util.*;
    // struttura di ogni oggetto contenuto nell'hashtable
    class ObjectInfo implements Serializable {
      static ObjectInfo lastRef = null;
      String sParameter;
      int iValue;
      ObjectInfo ref = lastRef;   
         // riferimento ad un oggetto dello stesso tipo,
         // giusto per complicare la copia
      public ObjectInfo( String _sParameter, int _iValue ) {
        sParameter = _sParameter;
        iValue     = _iValue;
        lastRef    = this;
      }
    }
public class TestPipedStream  {
  public static void main (String argv []) throws Exception {
    final Hashtable hSrcTable = new Hashtable();
          Hashtable hDstTable = new Hashtable();
    for (int i=0; i<90; i++) {
      hSrcTable.put("Key"+String.valueOf(i),new ObjectInfo("key",i));
    }
//    System.out.println( hSrcTable.toString()+"\n--------\n" );
 
    // ----------- START COPY SECTION -----------
    PipedInputStream  pisIn = new PipedInputStream() { };
    final ObjectOutputStream  oosOut  =
         new ObjectOutputStream( new PipedOutputStream( pisIn ) );
    ObjectInputStream oisIn = new ObjectInputStream( pisIn );
    new Thread(
      new Runnable() {
        public void run() { 
           try { oosOut.writeObject(hSrcTable); } 
           catch (IOException ioEx) {} } }
    ).start();
    hDstTable = (Hashtable) oisIn.readObject();
    // ----------- END COPY SECTION ----------- 
    // Tutto sommato si tratta solo di poche righe di codice
    // più qualche altro controllo che eventualmente qualcuno 
    // voglia aggiungere
//    System.out.println( hDstTable.toString()+"\n---------\n");
    // test deep copy with pipe vs shallow copy with clone
    Hashtable hCloneTable = (Hashtable)  hSrcTable.clone();
    ((ObjectInfo)hSrcTable.get( "Key80" )).iValue++;
    System.out.println( 
        ((ObjectInfo)hDstTable.get( "Key81" )).ref.iValue );
    System.out.println( 
        ((ObjectInfo)hSrcTable.get( "Key81" )).ref.iValue );
    System.out.println( 
        ((ObjectInfo)hCloneTable.get( "Key81" )).ref.iValue );
  }
}
Il risultato sarà di avere i 3 numeri 
80    // valore della deep copy, che rimane come quello originario
81    // valore della struttura originaria, che è appena 
      // stato incrementato di 1
81    // valore della struttura clonata da quella originaria 
      // prima della modifica, ovviamente risente dell'incremento
Ciao, Max.

In alcuni casi risulta di vera utilità:
Ehm. Di *cosa* stai parlando? Delle pipes? E a chi rispondi? :)


   scritta dal primo venga passata al secondo in modo
asincrono
... ma a me è rimasta la sensazione che tu abbia
sottovalutato l'utilità di tale meccanismo; forse mi sbaglio, ma ho
suggerito comunque un esempio che a me è sembrato molto utile per
utilizzare efficientemente le pipes in un problema non di poco conto come
la deep copy di una struttura dati anche molto complessa. Ho inoltre
rinominato il subject per far sì che la mia risposta venisse vista
semplicemente come un suggerimento di utilizzo delle pipes piuttosto che
come un'obiezione al tuo post.
Ciao, Max.
--------------------------------
Inviato via 
http://usenet.iol.it
 

piuttosto che come un'obiezione al tuo post.
Non preoccuparti: non c'e' nessun problema a fare obiezioni ai miei
post, anzi. :) Anche quando non sono pienamente centrate. ;-)
Di passaggio, nota pero' che il fatto che le pipe siano genericamente
utili (e che lo siano anche, in misura minore, i PipedStream di 
java.io
)
non risolve, ahime', il problema del poster originale, almeno non usando
i PipedStream. Li' (da quanto ho capito) lui ha delle classi gia' 
pronte che non puo' modificare, e che forniscono OutputStream, non
PipedOutputStream. 
Ora, ci sono almeno tre o quattro design che mi vengono in mente per
aggiungere piping dove originariamente non e' pensato. Ma prima (se :) di
lanciarmi a illustrarli volevo sapere se e' piping che vuole, o gli basta
un semplice buffer sincrono. 
Inoltre - visto il linguaggio tecnico non esattamente preciso del msg
originale - ho dei dubbi sul fatto che l'autore sia cosi' a conoscenza delle
peculiarita' del piping da non provare ad usare pipedstream dallo stesso
thread (magari mi sbaglio, s'intende, ed e' docente di computer science
al mit, nel qual caso chiedo venia). Quindi mi sono astenuto dal
mostrargli su una via su cui potrebbe facilmente inciampare senza nemmeno
rendersi conto del perche', quando magari tutto quel che vuole fare e'
prendere l'output totale di uno stream e usarlo come input da un'altra
parte. 
