javax.microedition.io
Interface Datagram

All Superinterfaces:

DataInput, DataOutput

public interface Datagram
extends DataInput, DataOutput

This class defines an abstract interface for datagram packets. The implementations of this interface hold data to be sent or received from a DatagramConnection object. Since this is an interface class, the internal structure of the datagram packets is not defined here. However, it is assumed that each implementation of this interface will provide the following fields / state variables (the actual implementation and the names of these fields may vary): buffer: the internal buffer in which data is stored offset: the read/write offset for the internal buffer length: the length of the data in datagram packet address: the destination or source address read/write pointer: a pointer that is added to the offset to point to the current data location during a read or write operation Reading and Writing The Datagram interface extends interfaces DataInput and DataOutput in order to provide a simple way to read and write binary data in and out of the datagram buffer instead of using getData and setData methods. Writing automatically increments length and reading will continue while the read/write pointer is less than length. Before any writing is done reset must be called. If setData() is to be used when reading or writing, any value for the offset parameter other than 0 is not supported. For example to write to datagram: datagram = connection.newDatagram(max); // Reset prepares the datagram for writing new message. datagram.reset(); // writeUTF automatically increases the datagram length. datagram.writeUTF("hello world"); connection.send(datagram); For example to read from a datagram (single use only): datagram = connection.newDatagram(max); connection.receive(datagram); message = datagram.readUTF(); Reusing Datagrams It should be noted the length above is returned from getLength and can have different meanings at different times. When sending length is the number of bytes to send. Before receiving length is the maximum number of bytes to receive. After receiving length is the number of bytes that were received. So when reusing a datagram to receive after sending or receiving, length must be set back to the maximum using setLength. datagram = connection.newDatagram(max); while (notDone) { // The last receive in the loop changed the length // so put it back to the maximum length. datagram.setLength(max); connection.receive(datagram); data = datagram.getData(); bytesReceived = datagram.getLength(); // process datagram ... } When reading instead of using getData the reset method must be used. datagram = connection.newDatagram(max); while (notDone) { // The last read in the loop changed the read pointer // so reset the pointer. datagram.reset(); datagram.setLength(max); connection.receive(datagram); message = datagram.readUTF(message); // process message ... } For example to reread a datagram: connection.receive(datagram); message = datagram.readUTF(message); len = datagram.getLength(); datagram.reset(); datagram.setLength(len); copy = datagram.readUTF(message);

Method Summary

String	getAddress() Get the address of the datagram.
byte[]	getData() Get the contents of the data buffer.
int	getLength() Get the length of the datagram.
int	getOffset() Get the offset.
void	reset() Zero the read/write pointer as well as the offset and length state variables.
void	setAddress(Datagram reference) Set datagram address, copying the address from another datagram.
void	setAddress(String addr) Set datagram address.
void	setData(byte[] buffer, int offset, int len) Set the buffer, offset and length state variables.
void	setLength(int len) Set the length state variable.

Methods inherited from interface java.io.DataInput

readBoolean, readByte, readChar, readDouble, readFloat, readFully, readFully, readInt, readLong, readShort, readUnsignedByte, readUnsignedShort, readUTF, skipBytes

Methods inherited from interface java.io.DataOutput

write, write, write, writeBoolean, writeByte, writeChar, writeChars, writeDouble, writeFloat, writeInt, writeLong, writeShort, writeUTF

Method Detail

getAddress

String getAddress()

Get the address of the datagram.

getData

byte[] getData()

Get the contents of the data buffer. Depending on the implementation, this operation may return the internal buffer or a copy of it. However, the user must not assume that the contents of the internal data buffer can be manipulated by modifying the data returned by this operation. Rather, the setData operation should be used for changing the contents of the internal buffer.

getLength

int getLength()

Get the length of the datagram.

getOffset

int getOffset()

Get the offset.

reset

void reset()

Zero the read/write pointer as well as the offset and length state variables.

setAddress

void setAddress(Datagram reference)

Set datagram address, copying the address from another datagram.

setAddress

void setAddress(String addr)
                throws IOException

Set datagram address. The actual addressing scheme is implementation-dependent. Please read the general comments on datagram addressing in DatagramConnection.java. Note that if the address of a datagram is not specified, then it defaults to that of the connection.

Throws:

IOException

setData

void setData(byte[] buffer,
             int offset,
             int len)

Set the buffer, offset and length state variables. Depending on the implementation, this operation may copy the buffer or just set the state variable buffer to the value of the buffer argument. However, the user must not assume that the contents of the internal data buffer can be manipulated by modifying the buffer passed on to this operation.

setLength

void setLength(int len)

Set the length state variable.