jubilee 2.1.0.rc1-java → 3.0.0.beta2-java

data/examples/chatapp/config.json

@@ -1,4 +0,0 @@
-{ "host": "0.0.0.0",
-  "port": 8080,
-  "event_bus": "/eventbus"
-}

data/lib/container.rb

@@ -1,117 +0,0 @@
-# Copyright 2011 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'core/wrapped_handler'
-
-module Vertx
-
-  # Deploy a verticle. The actual deploy happens asynchronously
-  # @param main [String] The main of the verticle to deploy
-  # @param config [Hash] JSON configuration for the verticle
-  # @param instances [FixNum] Number of instances to deploy
-  # @param block [Block] Block will be executed when deploy has completed - the first parameter passed to
-  # the block will be an exception or nil if no failure occurred, the second parameter will be the deployment id
-  def Vertx.deploy_verticle(main, config = nil, instances = 1, &block)
-    if config
-      json_str = JSON.generate(config)
-      config = org.vertx.java.core.json.JsonObject.new(json_str)
-    end
-    if block
-      block = ARWrappedHandler.new(block)
-    end
-    org.vertx.java.platform.impl.JRubyVerticleFactory.container.deployVerticle(main, config, instances, block)
-  end
-
-  # Deploy a worker verticle. The actual deploy happens asynchronously
-  # @param main [String] The main of the verticle to deploy
-  # @param config [Hash] JSON configuration for the verticle
-  # @param instances [FixNum] Number of instances to deploy
-  # @param block [Block] Block will be executed when deploy has completed - the first parameter passed to
-  # the block will be an exception or nil if no failure occurred, the second parameter will be the deployment id
-  def Vertx.deploy_worker_verticle(main, config = nil, instances = 1, multi_threaded = false, &block)
-    if config
-      json_str = JSON.generate(config)
-      config = org.vertx.java.core.json.JsonObject.new(json_str)
-    end
-    if block
-      block = ARWrappedHandler.new(block)
-    end
-    org.vertx.java.platform.impl.JRubyVerticleFactory.container.deployWorkerVerticle(main, config, instances, multi_threaded, block)
-  end
-
-  # Deploy a module. The actual deploy happens asynchronously
-  # @param module_name [String] The name of the module to deploy
-  # @param config [Hash] JSON configuration for the module
-  # @param instances [FixNum] Number of instances to deploy
-  # @param block [Block] Block will be executed when deploy has completed - the first parameter passed to
-  # the block will be an exception or nil if no failure occurred, the second parameter will be the deployment id
-  def Vertx.deploy_module(module_name, config = nil, instances = 1, &block)
-    if config
-      json_str = JSON.generate(config)
-      config = org.vertx.java.core.json.JsonObject.new(json_str)
-    end
-    if block
-      block = ARWrappedHandler.new(block)
-    end
-    org.vertx.java.platform.impl.JRubyVerticleFactory.container.deployModule(module_name, config, instances, block)
-  end
-
-  # Undeploy a verticle
-  # @param id [String] The deployment id  - the undeploy happens asynchronously
-  # @param block [Block] Block will be executed when undeploy has completed, an exception will be passed to the block
-  # as the first parameter if undeploy failed
-  def Vertx.undeploy_verticle(id, &block)
-    if block
-      block = ARWrappedHandler.new(block)
-    end
-    org.vertx.java.platform.impl.JRubyVerticleFactory.container.undeployVerticle(id, block)
-  end
-
-  # Undeploy a module
-  # @param id [String] The deployment id
-  # @param block [Block] Block will be executed when undeploy has completed, an exception will be passed to the block
-  # as the first parameter if undeploy failed
-  def Vertx.undeploy_module(id, &block)
-    if block
-      block = ARWrappedHandler.new(block)
-    end
-    org.vertx.java.platform.impl.JRubyVerticleFactory.container.undeployModule(id, block)
-  end
-
-  # Cause the container to exit
-  def Vertx.exit
-    org.vertx.java.platform.impl.JRubyVerticleFactory.container.exit
-  end
-
-  # Get config for the verticle
-  # @return [Hash] The JSON config for the verticle
-  def Vertx.config
-    if !defined? @@j_conf
-      @@j_conf = org.vertx.java.platform.impl.JRubyVerticleFactory.container.config
-      @@j_conf = JSON.parse(@@j_conf.encode) if @@j_conf
-    end
-    @@j_conf
-  end
-
-  # @return [Hash] Get the environment for the verticle
-  def Vertx.env
-    org.vertx.java.platform.impl.JRubyVerticleFactory.container.env
-  end
-
-  # @return [Logger] Get the logger for the verticle
-  def Vertx.logger
-    org.vertx.java.platform.impl.JRubyVerticleFactory.container.logger
-  end
-
-end

data/lib/core/buffer.rb

@@ -1,251 +0,0 @@
-# Copyright 2011-2012 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'core/shared_data'
-
-module Vertx
-
-  # A Buffer represents a sequence of zero or more bytes that can be written to or read from, and which expands
-  # as necessary to accomodate any bytes written to it.
-  #
-  # Buffers are used in many places in vert.x, for example to read/write data to/from {NetSocket}, {AsyncFile},
-  # {WebSocket}, {HttpClientRequest}, {HttpClientResponse}, {HttpServerRequest}, {HttpServerResponse} etc.
-  #
-  # There are two ways to write data to a Buffer: The first method involves methods that take the form set_XXX.
-  # These methods write data into the buffer starting at the specified position. The position does not have to be inside data that
-  # has already been written to the buffer; the buffer will automatically expand to encompass the position plus any data that needs
-  # to be written. All positions are measured in bytes and start with zero.
-  #
-  # The second method involves methods that take the form append-XXX; these methods append data at the end of the buffer.
-  # Methods exist to both set and append all primitive types, String and  other instances of Buffer.
-  #
-  # Data can be read from a buffer by invoking methods which take the form get_XXX. These methods take a parameter
-  # representing the position in the Buffer from where to read data.
-  #
-  # @author {http://tfox.org Tim Fox}
-  class Buffer
-
-    # @private
-    def initialize(j_buffer)
-      @buffer = j_buffer
-    end
-
-    # Creates a new empty buffer. The {#length} of the buffer immediately after creation will be zero.
-    # @param initial_size_hint [FixNum] is a hint to the system for how much memory
-    # to initially allocate to the buffer to prevent excessive automatic re-allocations as data is written to it.
-    def Buffer.create(initial_size_hint = 0)
-      Buffer.new(org.vertx.java.core.buffer.Buffer.new(initial_size_hint))
-    end
-
-    # Create a new Buffer from a String
-    # @param str [String] The String to encode into the Buffer
-    # @param enc [String] Encoding to use. Defaults to "UTF-8"
-    def Buffer.create_from_str(str, enc = "UTF-8")
-      Buffer.new(org.vertx.java.core.buffer.Buffer.new(str, enc))
-    end
-
-    # Return a String representation of the buffer.
-    # @param enc [String] The encoding to use. Defaults to "UTF-8"
-    # @return [String] a String representation of the buffer.
-    def to_s(enc = "UTF-8")
-      @buffer.toString(enc)
-    end
-
-    # Get the byte at position pos in the buffer.
-    # @param pos [FixNum] the position in the buffer from where to retrieve the byte
-    # @return [FixNum] the byte
-    def get_byte(pos)
-      @buffer.getByte(pos)
-    end
-
-    # Get the FixNum represented by a sequence of bytes starting at position pos in the buffer.
-    # @param pos [FixNum] the position in the buffer from where to retrieve the FixNum.
-    # @param bytes [FixNum] the number of bytes to retrieve from position pos to create the FixNum. Valid values are 1, 2, 4 and 8.
-    # @return [FixNum] the FixNum
-    def get_fixnum(pos, bytes)
-      case bytes
-        when 1
-          @buffer.getByte(pos)
-        when 2
-          @buffer.getShort(pos)
-        when 4
-          @buffer.getInt(pos)
-        when 8
-          @buffer.getLong(pos)
-        else
-          raise "bytes must be 1, 2, 4, or 8"
-      end
-    end
-
-    # Get the Float represented by a sequence of bytes starting at position pos in the buffer.
-    # @param pos [Float] the position in the buffer from where to retrieve the Float.
-    # @param bytes [Float] the number of bytes to retrieve from position pos to create the Float. Valid values are 4 and 8.
-    # @return [Float] the Float
-    def get_float(pos, bytes)
-      case bytes
-        when 4
-          @buffer.getFloat(pos)
-        when 8
-          @buffer.getDouble(pos)
-        else
-          raise "bytes must be 4 or 8"
-      end
-    end
-
-    # Return bytes from the buffer interpreted as a String
-    # @param pos [FixNum] the position in the buffer from where to start reading
-    # @param end_pos [FixNum] the position in the buffer to end reading
-    # @param enc [String] The encoding to use
-    # @return [String] the String
-    def get_string(pos, end_pos, enc = 'UTF-8')
-      @buffer.getString(pos, end_pos, enc)
-    end
-
-    # Return bytes in the buffer as a Buffer
-    # @param start_pos [FixNum] - the position in this buffer from where to start the copy.
-    # @param end_pos [FixNum] - the copy will be made up to index end_pos - 1
-    # @return [Buffer] the copy
-    def get_buffer(pos, end_pos)
-      j_buff = @buffer.getBuffer(pos, end_pos)
-      Buffer.new(j_buff)
-    end
-
-    # Appends another buffer to the end of this buffer. The buffer will expand as necessary to accomodate any bytes
-    # written.
-    # @param buff [Buffer] the buffer to append.
-    # @return [Buffer] a reference to self so multiple operations can be appended together.
-    def append_buffer(buff)
-      @buffer.appendBuffer(buff._to_java_buffer)
-      self
-    end
-
-    # Appends a FixNum to the end of this buffer. The buffer will expand as necessary to accomodate any bytes written.
-    # @param num [FixNum] the fixnum to append.
-    # @param bytes [FixNum] the number of bytes to write in the buffer to represent the fixnum. Valid values are 1, 2, 4 and 8.
-    # @return [Buffer] a reference to self so multiple operations can be appended together.
-    def append_fixnum(num, bytes)
-      case bytes
-        when 1
-          @buffer.appendByte(num)
-        when 2
-          @buffer.appendShort(num)
-        when 4
-          @buffer.appendInt(num)
-        when 8
-          @buffer.appendLong(num)
-        else
-          raise "bytes must be 1, 2, 4, or 8"
-      end
-      self
-    end
-
-    # Appends a Float to the end of this buffer. The buffer will expand as necessary to accomodate any bytes written.
-    # @param num [Float] the float to append.
-    # @param bytes [FixNum] the number of bytes to write in the buffer to represent the float. Valid values are 4 and 8.
-    # @return [Buffer] a reference to self so multiple operations can be appended together.
-    def append_float(num, bytes)
-      case bytes
-        when 4
-          @buffer.appendFloat(num)
-        when 8
-          @buffer.appendDouble(num)
-        else
-          raise "bytes must be 4 or 8"
-      end
-    end
-
-    # Appends a string to the end of this buffer. The buffer will expand as necessary to accomodate any bytes written.
-    # @param str [String] the string to append.
-    # @param enc [String] the encoding to use. Defaults to "UTF-8"
-    # @return [Buffer] a reference to self so multiple operations can be appended together.
-    def append_str(str, enc = "UTF-8")
-      @buffer.appendString(str, enc)
-      self
-    end
-
-    # Sets bytes in the buffer to a representation of a FixNum. The buffer will expand as necessary to accomodate any bytes written.
-    # @param pos [FixNum] - the position in the buffer from where to start writing the FixNum
-    # @param num [FixNum]  - the FixNum to write
-    # @param bytes [FixNum] - the number of bytes to write to represent the FixNum. Valid values are 1, 2, 4, and 8
-    # @return [Buffer] a reference to self so multiple operations can be appended together.
-    def set_fixnum(pos, num, bytes)
-      case bytes
-        when 1
-          @buffer.setByte(pos, num)
-        when 2
-          @buffer.setShort(pos, num)
-        when 4
-          @buffer.setInt(pos, num)
-        when 8
-          @buffer.setLong(pos, num)
-        else
-          raise "bytes must be 1, 2, 4, or 8"
-      end
-      self
-    end
-
-    # Sets bytes in the buffer to a representation of a Float. The buffer will expand as necessary to accomodate any bytes written.
-    # @param pos [FixNum] - the position in the buffer from where to start writing the Float
-    # @param num [Float]  - the Float to write
-    # @param bytes [FixNum] - the number of bytes to write to represent the Float. Valid values are 4 and 8
-    # @return [Buffer] a reference to self so multiple operations can be appended together.
-    def set_float(pos, num, bytes)
-      case bytes
-        when 4
-          @buffer.setFloat(pos, num)
-        when 8
-          @buffer.setDouble(pos, num)
-        else
-          raise "bytes must be 4 or 8"
-      end
-      self
-    end
-
-    # Sets bytes in this buffer to the bytes of the specified buffer. The buffer will expand as necessary to accomodate any bytes written.
-    # @param pos [FixNum] - the position in this buffer from where to start writing the buffer
-    # @param buff [Buffer] - the buffer to write into this buffer
-    # @return [Buffer] a reference to self so multiple operations can be appended together.
-    def set_buffer(pos, buff)
-      @buffer.setBytes(pos, buff._to_java_buffer)
-      self
-    end
-
-    # Set bytes in the buffer to the string encoding in the specified encoding
-    # @param pos [FixNum] - the position in this buffer from where to start writing the string
-    # @param str [String] the string
-    # @param enc [String] the encoding
-    # @return [Buffer] a reference to self so multiple operations can be appended together.
-    def set_string(pos, str, enc = 'UTF-8')
-      @buffer.setString(pos, str, enc)
-      self
-    end
-
-    # @return [FixNum] the length of this buffer, in bytes.
-    def length
-      @buffer.length
-    end
-
-    # Get a copy of the entire buffer.
-    # @return [Buffer] the copy
-    def copy
-      Buffer.new(@buffer.copy())
-    end
-
-    # @private
-    def _to_java_buffer
-      @buffer
-    end
-
-  end
-end

data/lib/core/datagram.rb

@@ -1,280 +0,0 @@
-# Copyright 2013 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-require 'core/buffer'
-require 'core/wrapped_handler'
-require 'core/network_support'
-require 'core/streams'
-require 'socket'
-
-module Vertx
-
-
-  #
-  # A Datagram socket which can be used to send data to remote Datagram servers and receive [DatagramPacket]s .
-  #
-  # Usually you use a Datragram Client to send UDP over the wire. UDP is connection-less which means you are not connected
-  # to the remote peer in a persistent way. Because of this you have to supply the address and port of the remote peer
-  # when sending data.
-  #
-  # You can send data to ipv4 or ipv6 addresses, which also include multicast addresses.
-  #
-  # @author Norman Maurer
-  class DatagramSocket
-    include ReadSupport, DrainSupport, NetworkSupport
-
-    def initialize(ipv4=nil)
-      if ipv4 == nil
-        family = nil
-      elsif ipv4
-        family = org.vertx.java.core.datagram.InternetProtocolFamily::IPv4
-      else
-        family = org.vertx.java.core.datagram.InternetProtocolFamily::IPv6
-      end
-      @j_del = org.vertx.java.platform.impl.JRubyVerticleFactory.vertx.createDatagramSocket(family)
-      @local_address = nil
-    end
-
-    # Write the given {@link org.vertx.java.core.buffer.Buffer} to the {@link java.net.InetSocketAddress}. The {@link org.vertx.java.core.Handler} will be notified once the
-    # write completes.
-    #
-    # @param [String] host              the host address of the remote peer
-    # @param [FixNum] port              the host port of the remote peer
-    # @param [Buffer] packet            the buffer to write
-    # @param [Block] hndlr              the handler to notify once the write completes.
-    # @return [DatagramSocket] self     itself for method chaining
-    def send(host, port, packet,  &hndlr)
-      @j_del.send(packet._to_java_buffer, host, port, ARWrappedHandler.new(hndlr) { |j_del| self })
-      self
-    end
-
-    #
-    # Write the given {@link String} to the {@link InetSocketAddress} using UTF8 encoding. The {@link Handler} will be notified once the
-    # write completes.
-    #
-    #
-    # @param [String] host              the host address of the remote peer
-    # @param [FixNum] port              the host port of the remote peer
-    # @param [String] str               the data to send
-    # @param [String] enc               the charset to use to encode the data
-    # @param [Block] hndlr              the handler to notify once the write completes.
-    # @return [DatagramSocket] self     itself for method chaining
-    def send_str(host, port, str, enc = 'UTF-8',  &hndlr)
-      @j_del.send(str, enc, host, port, ARWrappedHandler.new(hndlr) { |j_del| self })
-      self
-    end
-
-    #
-    # set the {@link java.net.StandardSocketOptions#SO_BROADCAST} option.
-    #
-    def broadcast=(val)
-      @j_del.setBroadcast(val)
-      self
-    end
-
-    #
-    # set the {@link java.net.StandardSocketOptions#SO_BROADCAST} option.
-    #
-    def broadcast?
-      @j_del.isBroadcast
-    end
-
-    #
-    # Set the {@link java.net.StandardSocketOptions#IP_MULTICAST_LOOP} option.
-    #
-    def multicast_loopback_mode=(val)
-      @j_del.setMulticastLoopbackMode(val)
-       self
-    end
-
-    #
-    # Set the {@link java.net.StandardSocketOptions#IP_MULTICAST_LOOP} option.
-    #
-    def multicast_loopback_mode?
-      @j_del.isMulticastLoopbackMode
-    end
-
-    #
-    # Set  the {@link java.net.StandardSocketOptions#IP_MULTICAST_TTL} option.
-    #
-    def multicast_time_to_live=(val)
-      @j_del.setMulticastTimeToLive(val)
-      self
-    end
-
-    #
-    # Gets  the {@link java.net.StandardSocketOptions#IP_MULTICAST_TTL} option.
-    #
-    def multicast_time_to_live
-      @j_del.getMulticastTimeToLive
-    end
-
-    #
-    # Set the {@link java.net.StandardSocketOptions#IP_MULTICAST_IF} option.
-    #
-    def multicast_network_interface=(val)
-      @j_del.setMulticastNetworkInterface(val)
-      self
-    end
-
-    #
-    # Gets the {@link java.net.StandardSocketOptions#IP_MULTICAST_IF} option.
-    #
-    def multicast_network_interface
-      @j_del.getMulticastNetworkInterface
-    end
-
-
-    #
-    # Close the socket asynchronous and notifies the handler once done.
-    #
-    # @param [Block] hndlr the handler to notify once the opeation completes.
-    def close(&hndlr)
-      if hndlr
-        @j_del.close(ARWrappedHandler.new(hndlr))
-      else
-        @j_del.close
-      end
-    end
-
-    #
-    # Return the Addrinfo to which the local end of the socket is bound
-    #
-    # @return [Addrinfo] local_addr   the local address to which the socket is bound if it is bound at all.
-    def local_address
-      if !@local_address
-        addr = j_del.localAddress
-        if addr != null
-          @local_address = Addrinfo.tcp(@local_address.getAddress().getHostAddress(), @@local_address.getPort())
-        end
-      end
-      @local_address
-    end
-
-    #
-    # Joins a multicast group and so start listen for packets send to it. The {@link Handler} is notified once the operation completes.
-    #
-    #
-    # @param  [String]            multicast_address   the address of the multicast group to join
-    # @param  [String]            source              the address of the source for which we will listen for mulicast packets
-    # @param  [String]            network_interface   the network interface on which to listen for packets.
-    # @param  [Block]             hndlr               the handler to notify once the opeation completes.
-    # @return [DatagramSocket]    self                itself for method chaining
-    def listen_multicast_group(multicast_address, source = nil, network_interface = nil,  &hndlr)
-      if network_interface != nil && source != nil
-        @j_del.listenMulticastGroup(multicast_address, network_interface, source, ARWrappedHandler.new(hndlr) { |j_del| self })
-      else
-        @j_del.listenMulticastGroup(multicast_address, ARWrappedHandler.new(hndlr) { |j_del| self })
-      end
-      self
-    end
-
-    #
-    # Leaves a multicast group and so stop listen for packets send to it on the given network interface.
-    # The {@link Handler} is notified once the operation completes.
-    #
-    #
-    # @param  [String]            multicast_address   the address of the multicast group to leave
-    # @param  [String]            source              the address of the source for which we will listen for mulicast packets
-    # @param  [String]            network_interface   the network interface on which to listen for packets.
-    # @param  [Block]             hndlr               the handler to notify once the opeation completes.
-    # @return [DatagramSocket]    self                itself for method chaining
-    def unlisten_multicast_group(multicast_address, source = nil, network_interface = nil, &hndlr)
-      if network_interface != nil && source != nil
-        @j_del.unlistenMulticastGroup(multicast_address, network_interface, source, ARWrappedHandler.new(hndlr) { |j_del| self })
-      else
-        @j_del.unlistenMulticastGroup(multicast_address, ARWrappedHandler.new(hndlr) { |j_del| self })
-      end
-      self
-    end
-
-    #
-    # Block the given sourceToBlock address for the given multicastAddress on the given network interface and notifies
-    # the {@link Handler} once the operation completes.
-    #
-    #
-    # @param  [String]          multicast_address   the address for which you want to block the sourceToBlock
-    # @param  [String]          source_to_block     the source address which should be blocked. You will not receive an multicast packets
-    #                                               for it anymore.
-    # @param  [String]          network_interface   the network interface on which the blocking should accour.
-    # @param  [Block]           hndlr               the handler to notify once the opeation completes.
-    # @return [DatagramSocket]  self                itself for method chaining
-    #
-    def block_multicast_group(multicast_address, source_to_block, network_interface = nil, &hndlr)
-      if network_interface != nil
-        @j_del.blockMulticastGroup(multicast_address, network_interface, source_to_block, ARWrappedHandler.new(hndlr) { |j_del| self })
-      else
-        @j_del.blockMulticastGroup(multicast_address, source_to_block, ARWrappedHandler.new(hndlr) { |j_del| self })
-      end
-      self
-    end
-
-    #
-    # Listen for incoming [DatagramPacket]s on the given address and port.
-    #
-    #
-    # @param  [FixNum]          port                the port on which to listen for incoming [DatagramPacket]s
-    # @param  [String]          address             the address on which to listen for incoming [DatagramPacket]s
-    # @param  [Block]           hndlr               the handler to notify once the opeation completes.
-    # @return [DatagramSocket]  self                itself for method chaining
-    #
-    def listen(port, address = '0.0.0.0', &hndlr)
-      @j_del.listen(address, port, ARWrappedHandler.new(hndlr) { |j_del| self })
-      self
-    end
-
-
-    # Set a data handler. As data is read, the handler will be called with the data.
-    #
-    # @param [Block] hndlr. The data handler
-    def data_handler(&hndlr)
-      @j_del.dataHandler(Proc.new { |j_packet|
-        hndlr.call(DatagramPacket.new(j_packet))
-      })
-      self
-    end
-  end
-
-
-  # A received Datagram packet (UDP) which contains the data and information about the sender of the data itself.
-  #
-  # @author Norman Maurer
-  class DatagramPacket
-    def initialize(j_packet)
-      @j_packet = j_packet
-      @sender = nil
-      @data = nil
-    end
-
-    # Return the address of the sender of this [DatagramPacket].
-    #
-    # @return [AddrInfo] addr   the address of the sender
-    def sender
-      if !@sender
-        @sender = Addrinfo.tcp(@j_packet.sender().getAddress().getHostAddress(), @j_packet.sender().getPort())
-      end
-      @sender
-    end
-
-    # Return the data which was received
-    #
-    # @return [Buffer] data   the data which was received
-    def data
-      if !@data
-        @data = Buffer.new(@j_packet.data())
-      end
-      @data
-    end
-  end
-end