DidaWiki

/**
 * @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>Preferences>Java>Code Generation>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;
	}
 
}