o != arg0 is the same as !(o == (arg0)).
o != arg0 is the same as !(o == (arg0)).
the object to compare against this object for dis-equality.
false if the receiver object is equivalent to the argument; true otherwise.
o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).
o == arg0 is the same as if (o eq null) arg0 eq null else o.equals(arg0).
the object to compare against this object for equality.
true if the receiver object is equivalent to the argument; false otherwise.
o == arg0 is the same as o.equals(arg0).
o == arg0 is the same as o.equals(arg0).
the object to compare against this object for equality.
true if the receiver object is equivalent to the argument; false otherwise.
The local address to which the socket is bound.
The local address to which the socket is bound.
This method is used to cast the receiver object to be of type T0.
This method is used to cast the receiver object to be of type T0.
Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression1.asInstanceOf[String] will throw a ClassCastException at runtime, while the expressionList(1).asInstanceOf[List[String]] will not. In the latter example, because the type argument is erased as
part of compilation it is not possible to check whether the contents of the list are of the requested typed.
the receiver object.
Whether or not the socket's broadcast flag is set.
Whether or not the socket's broadcast flag is set. The broadcast
flag corresponds to the SO_BROADCAST socket option. When
this option is enabled, datagram sockets will receive packets sent
to a broadcast address, and they are permitted to send packets to a
broadcast address.
whether or not the broadcast flag is set
Change the value of the socket's broadcast flag.
Change the value of the socket's broadcast flag. The broadcast flag
corresponds to the SO_BROADCAST socket option. When this
option is enabled, datagram sockets will receive packets sent to a
broadcast address, and they are permitted to send packets to a
broadcast address.
true to enable broadcast, false to disable it.
This method creates and returns a copy of the receiver object.
This method creates and returns a copy of the receiver object.
The default implementation of the clone method is platform dependent.
a copy of the receiver object.
Close the socket.
Close the socket.
This method is used to test whether the argument (arg0) is a reference to the
receiver object (this).
This method is used to test whether the argument (arg0) is a reference to the
receiver object (this).
The eq method implements an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation] on
non-null instances of AnyRef:
* It is reflexive: for any non-null instance x of type AnyRef, x.eq(x) returns true.
* It is symmetric: for any non-null instances x and y of type AnyRef, x.eq(y) returns true if and
only if y.eq(x) returns true.
* It is transitive: for any non-null instances x, y, and z of type AnyRef if x.eq(y) returns true and y.eq(z) returns true, then x.eq(z) returns true.
Additionally, the eq method has three other properties.
* It is consistent: for any non-null instances x and y of type AnyRef, multiple invocations of
x.eq(y) consistently returns true or consistently returns false.
* For any non-null instance x of type AnyRef, x.eq(null) and null.eq(x) returns false.
* null.eq(null) returns true.
When overriding the equals or hashCode methods, it is important to ensure that their behavior is
consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2), they
should be equal to each other (o1 == o2) and they should hash to the same value (o1.hashCode == o2.hashCode).
the object to compare against this object for reference equality.
true if the argument is a reference to the receiver object; false otherwise.
This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.
This method is used to compare the receiver object (this) with the argument object (arg0) for equivalence.
The default implementations of this method is an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence
relation]:
* It is reflexive: for any instance x of type Any, x.equals(x) should return true.
* It is symmetric: for any instances x and y of type Any, x.equals(y) should return true if and
only if y.equals(x) returns true.
* It is transitive: for any instances x, y, and z of type AnyRef if x.equals(y) returns true and
y.equals(z) returns true, then x.equals(z) should return true.
If you override this method, you should verify that your implementation remains an equivalence relation.
Additionally, when overriding this method it is often necessary to override hashCode to ensure that objects
that are "equal" (o1.equals(o2) returns true) hash to the same
scala.Int
(o1.hashCode.equals(o2.hashCode)).
the object to compare against this object for equality.
true if the receiver object is equivalent to the argument; false otherwise.
This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.
This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.
The details of when and if the finalize method are invoked, as well as the interaction between finalizeand non-local returns and exceptions, are all platform dependent.
Returns a representation that corresponds to the dynamic class of the receiver object.
Returns a representation that corresponds to the dynamic class of the receiver object.
The nature of the representation is platform dependent.
a representation that corresponds to the dynamic class of the receiver object.
Returns a hash code value for the object.
Returns a hash code value for the object.
The default hashing algorithm is platform dependent.
Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet
not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0.
However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have
identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure
to verify that the behavior is consistent with the equals method.
the hash code value for the object.
This method is used to test whether the dynamic type of the receiver object is T0.
This method is used to test whether the dynamic type of the receiver object is T0.
Note that the test result of the test is modulo Scala's erasure semantics. Therefore the expression1.isInstanceOf[String] will return false, while the expression List(1).isInstanceOf[List[String]] will
return true. In the latter example, because the type argument is erased as part of compilation it is not
possible to check whether the contents of the list are of the requested typed.
true if the receiver object is an instance of erasure of type T0; false otherwise.
o.ne(arg0) is the same as !(o.eq(arg0)).
o.ne(arg0) is the same as !(o.eq(arg0)).
the object to compare against this object for reference dis-equality.
false if the argument is not a reference to the receiver object; true otherwise.
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
The local port to which the socket is bound.
The local port to which the socket is bound.
Receive a buffer of bytes from the socket.
Receive a buffer of bytes from the socket. The buffer is dynamically
allocated and returned. For more efficiency, use the version ofreceive() that takes a caller-supplied buffer.
maximum number of bytes to receive
a tuple containing the buffer of data (of size length)
and the actual number of bytes read. The buffer might be longer
than the number of bytes read.
Receive a buffer of bytes from the socket, writing them into a caller-supplied fixed-size buffer.
Receive a buffer of bytes from the socket, writing them into a caller-supplied fixed-size buffer. One simple way to create such a buffer:
// Create a 512-byte buffer initialized to zeros. val buf = Array.make[Byte](512, 0)
the buf into which to read the data
actual number of bytes read
Receive a string from the socket, using a caller-supplied receive buffer to hold the bytes actually received over the wire.
Receive a string from the socket, using a caller-supplied receive buffer to hold the bytes actually received over the wire. The string is assumed to have been encoded in UTF-8 for transmission and is decoded accordingly.
the buf into which to read the data
the string
Receive a string from the socket, using a caller-supplied receive buffer to hold the bytes actually received over the wire.
Receive a string from the socket, using a caller-supplied receive buffer to hold the bytes actually received over the wire. The string is assumed to have been encoded in the specified encoding and is decoded accordingly.
the buf into which to read the data
the encoding to use when decoding the string
the string
Receive a string from the socket.
Receive a string from the socket. The string is assumed to have been encoded in UTF-8 for transmission and is decoded accordingly.
maximum number of bytes (not characters) expected
the string
Receive a string from the socket.
Receive a string from the socket. The string is assumed to have been encoded in the specified encoding and is decoded accordingly.
maximum number of bytes (not characters) expected
the encoding to use when decoding the string
the string
Send data over the socket.
Send data over the socket. Accepts any sequence of bytes (e.g.,Array[Byte], List[Byte]).
the bytes to send
Send string data over the socket.
Send string data over the socket. Converts the string to UTF-8 bytes, then sends the bytes.
the string to send
the IP address to receive the string
the destination port on the remote machine
Send string data over the socket.
Send string data over the socket. The internal UTF-16 strings are converted to the specified encoding before being sent.
the string to send
the encoding to use
the IP address to receive the string
the destination port on the remote machine
Returns a string representation of the object.
Returns a string representation of the object.
The default representation is platform dependent.
a string representation of the object.
A
UDPDatagramSocketobject represents a UDP datagram socket, providing a simpler interface to sending and receiving UDP packets than the one provided by the Java JDK.Sending UDP Datagrams
The easiest way to explain how to use this API is with some code. So, without further ado, the following example shows how you might send the string "foo" to port 2003 on host "foo.example.com".
// Import the appropriate stuff. import grizzled.net._ // First, create an grizzled.net.IPAddress object for the destination // machine. val address = IPAddress("foo.example.com") // Next, create the socket object. Since we're sending the packet, // we don't care what the local port is. By not specifying one, we allow // the operating system to choose one one for us. Similarly, by not // passing an explicit address, we indicate that the API should bind to a // wildcard address, so that the packet can go out over any appropriate // interface. val socket = UDPDatagramSocket() // Next, use the sendString() method to send the string socket.sendString("foo", address, 2003) // Finally, close the socket. socket.close()That's pretty simple. However, using the utility methods provided by the
UDPDatagramSocketcompanion object, we can further simplify the above code:// Import the appropriate stuff. import grizzled.net._ UDPDatagramSocket.sendString("foo", IPAddress("foo.example.com"), 2003)The
sendString()method in the companion object takes care of allocating the socket, sending the packet, and closing the socket. Obviously, if you're planning on sending multiple packets at once, you'll want to use the first example (perhaps in a loop), so you're not constantly allocating and deallocating sockets. But sending a one-shot UDP packet can be as simple as one line of code, as shown in the second example.Sending binary data is not much more complicated. You have to convert the data to a stream of bytes, which the server must then decode. After that, however, sending the bytes isn't much more difficult than sending a string. Here's an example, which assumes that you have already encoded the data to be send into an array of bytes.
// Import the appropriate stuff. import grizzled.net._ // Encode the data into bytes. (Not shown.) val data: Array[Byte] = encodeTheData() // Create the socket object. val socket = UDPDatagramSocket() // Send the data. socket.send(data, IPAddress("foo.example.com"), 2003) // Finally, close the socket. socket.close()Once again, there's a simple utility method that does most of the work for you:
// Import the appropriate stuff. import grizzled.net._ // Encode the data into bytes. (Not shown.) val data: Array[Byte] = encodeTheData() // Send the data. UDPDatagramSocket.send(data, IPAddress("foo.example.com"), 2003)Receiving UDP Datagrams
When receiving UDP datagrams, you must first bind to an incoming socket. That is, you must listen on the port to which clients are sending their packets. In this example, we create the socket object with the receiving port, and we allow the wildcard address to be used on the local machine (permitting us to receive packets on any interface).
Next, we want to receive and process the incoming data. Let's assume that we're receiving the "foo" string (or, for that matter, any string) being sent by the sample sender, above.
// Receive and print strings. while (true) println(socket.receiveString(1024))That code says, "Wait for incoming strings, using a 1024-byte buffer. Then, decode the strings and print them to standard output.
Receiving bytes isn't much more difficult.
// Allocate a byte buffer. For efficiency, we'll re-use the same buffer // on every incoming message. val buf = Array.make[Byte](1024, 0) // Receive and process the incoming bytes. The process() method isn't // shown. while (true) { val totalRead = socket.receive(buf) process(buf, totalRead) }The above loop can be made even simpler (though a little more obscure), since the
receive()method is filling our buffer and returning a count of the number of bytes it put into the buffer:while (true) process(buf, socket.receive(buf))