<code java>
/**
 * @author Danelutto Marco
 *
 * Questa classe permette la serializzazione e deserializzazione di oggetti nei DatagramPacket. 
 * Per spedire un oggetto serializzato in un DatagramPacket, si crea un oggetto ODP con il costruttore
 * ODP(Object o). Successivamente si utilizza il metodo DatagramPacket getDatagramPacket(InetAddress address, int 
port) 
 * per ottenere il datagram packet da spedire, che contiene l'oggetto o serializzato nel payload.
 * 
 * Per ricevere un oggetto serializzato in un pacchetto, si usa il metodo statico ODP getODP(DatagramPacket dp) 
 * per ottenere un ODP e quindi si invoca il metodo Object getObject() sull'oggetto ODP.
 * 
 */

/*
 * Created on Nov 13, 2003
 *
 * To change the template for this generated file go to
 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments
 */

package TFTPudp;
import java.net.*;
import java.io.*;


public class ODP {
        private static final int MAX_UDP_PAYLOAD = 65507;
        /** 
         * variabile utilizzata per memorizzare l'oggetto che deve essere 
         * (o che e' stato) serializzato mediante il DatagramPacket.
         */
        private Object o = null;

        /** 
         * costruttore per la creazione di un ODP 
         * Questo costruttore si usa per creare un pacchetto da spedire.
         * @param o l'oggetto da serializzare nel pacchetto
         */
        public ODP(Object o) {
                this.o = o;
        }


        /**
         * creazione di un oggetto ODP a partire da un pacchetto DatagramPacket. Si passa il datagram packet come 
parametro 
         * e da questo si ottiene l'oggetto che era stato incaspulato come payload
         * @param dp  il DatagramPacket da cui si crea l'oggetto ODP
         * @return l'oggetto ODP con l'object deserializzato in o
         */
        public static ODP getODP(DatagramPacket dp) throws ClassNotFoundException, IOException {
                ODP o = null;
                ByteArrayInputStream bis = new ByteArrayInputStream(dp.getData());
                ObjectInputStream ois = new ObjectInputStream(bis);
                o = new ODP(ois.readObject());
                return o;
        }

        /**
         * metodo per ottenere un DatagramPacket dall'oggetto ODP
         * @param addr l'indirizzo da utilizzare per la spedizione del pacchetto
         * @param port porta destinazione per il pacchetto
         * @return il datagram packet con l'oggetto serializzato nel payload
         * @throws Exception 
         */
        public DatagramPacket getDatagramPacket(InetAddress addr, int port) throws IOException {
                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ObjectOutputStream oos;
                try {
                        oos = new ObjectOutputStream(bos);
                        oos.writeObject(o);
                } catch (IOException e) {
                        e.printStackTrace();
                }
                byte[] buf = bos.toByteArray();
                if(buf.length > MAX_UDP_PAYLOAD)
                        throw new IOException("Object too big");
                DatagramPacket dp = new DatagramPacket(buf, buf.length, addr, port);
                return (dp);
        }

        /**
         * utilizzata per prelevare l'oggetto "deserializzato" dal pacchetto
         * @return l'oggetto deserializzato dalla getODP(DatagramPacket) (o memorizzato mediante la ODP(Object)
         * 
         */
        public Object getObject() {
                return o;
        }

}

</code>