
API equivalence between the Java and Lua implementations:

net.rudp.ReliableServerSocket
 * lac.mrudp.server
   |ReliableServerSocket()
   |ReliableServerSocket(port)
   |ReliableServerSocket(port, backlog)
   |ReliableServerSocket(port, backlog, bindAddress)
    * lac.mrudp.server.new(scheduler, port, acklog, bindaddr)
   ReliableServerSocket(sock, backlog)
    - n/a
   accept()
    * serverskt:accept()
   bind(endpoint)
    * serverskt:bind(host, port)
   bind(endpoint, backlog)
    * serverskt:bind(host, port)
      -- backlog is ignored in Java version of this method.
   close()
    * serverskt:close()
   getInetAddress()
    * serverskt:getsockname()
   getLocalPort()
    * serverskt:getsockname()
   getLocalSocketAddress()
    * serverskt:getsockname()
   isBound()
    * serverskt.bound
   isClosed()
    * serverskt.closed
   setSoTimeout(timeout)
    * serverskt.timeout
   getSoTimeout()
    * serverskt.timeout
   ----- private: -----
   ReliableClientSocket addClientSocket(SocketAddress endpoint)
    * lac.mrudp.server.add_client_socket(self, host, port, endpoint)
   SocketAddress addUuidEndpoint(UUID uuid, SocketAddress endpoint)
    * n/a
   ReliableClientSocket removeClientSocket(SocketAddress endpoint)
    * lac.mrudp.server.remove_client_socket(self, host, port)
   boolean hasClientSocket(SocketAddress endpoint)
    * n/a
   boolean hasUuidClient(UUID uuid)
    * n/a
   ----- inner classes: -----
   net.rudp.ReliableServerSocket.ReceiverThread
    * lac.mrudp.server.receiver_fn
   net.rudp.ReliableServerSocket.ReliableClientSocket
    * n/a
   
net.rudp.ReliableSocket
 * lac.mrudp.client
   ReliableSocket()
   |ReliableSocket(ReliableSocketProfile profile)
   |ReliableSocket(String host, int port)
   |ReliableSocket(InetAddress address, int port, InetAddress localAddr, int localPort)
   |ReliableSocket(String host, int port, InetAddress localAddr, int localPort)
   |ReliableSocket(InetSocketAddress inetAddr, InetSocketAddress localAddr)
   |ReliableSocket(DatagramSocket sock)
   |ReliableSocket(DatagramSocket sock, boolean withSockThread)
   |ReliableSocket(DatagramSocket sock, ReliableSocketProfile profile)
   |ReliableSocket(DatagramSocket sock, ReliableSocketProfile profile, boolean withSockThread)
    * lac.mrudp.client.new(scheduler, address, scheduler, server, config)
   void init(DatagramSocket sock, ReliableSocketProfile profile)
    * n/a
   void bind(SocketAddress bindpoint)
    * n/a
   void connect(SocketAddress endpoint)
    * clientskt:connect(host, port)
   void connect(SocketAddress endpoint, int timeout)
    * clientskt:connect(host, port, timeout)
   SocketChannel getChannel()
    - n/a
   InetAddress getInetAddress()
    - n/a
   int getPort()
    * clientskt.port
   SocketAddress getRemoteSocketAddress()
    * clientskt.host, clientskt.port
   InetAddress getLocalAddress()
    * clientskt:getsockname()
   int getLocalPort()
    * clientskt:getsockname()
   SocketAddress getLocalSocketAddress()
    * clientskt:getsockname()
   InputStream getInputStream()
    - n/a
   OutputStream getOutputStream()
    - n/a
   void closeImpl()
    * lac.mrudp.client.close_impl(self)
   void close()
    * clientskt:close()
   boolean isBound()
    * n/a
   boolean isConnected()
    * clientskt.connected
   boolean isClosed()
    * clientskt.closed
   void setUUID(UUID uuid)
    * clientskt.uuid
   void setSoTimeout(int timeout)
    * clientskt.timeout
   void setSendBufferSize(int size)
    * clientskt.send_buf_size
   int getSendBufferSize()
    * clientskt.send_buf_size
   void setReceiveBufferSize(int size)
    * clientskt.recv_buf_size
   int getReceiveBufferSize()
    * clientskt.recv_buf_size
   void setTcpNoDelay(boolean on)
    - n/a
   boolean getTcpNoDelay()
    - n/a
   void setKeepAlive(boolean on)
    * clientskt:set_keepalive(on)
   boolean getKeepAlive()
    * clientskt.keepalive
   void shutdownInput()
    * clientskt:shutdown_input()
   void shutdownOutput()
    * clientskt:shutdown_input()
   boolean isInputShutdown()
    * clientskt.in_shut
   boolean isOutputShutdown()
    * clientskt.out_shut
   void reset()
   |void reset(ReliableSocketProfile profile)
    * clientskt:reset(config)
   int write(byte[] b, int off, int len)
    * clientskt:write(...)
   int read(byte[] b, int off, int len)
    * clientskt:read(mode)
   void addListener(ReliableSocketListener listener)
    * ?
   void removeListener(ReliableSocketListener listener)
    * ?
   void addStateListener(ReliableSocketStateListener stateListener)
    * ?
   void removeStateListener(ReliableSocketStateListener stateListener)
    * ?
   ----- private: -----
   void sendSegmentImpl(Segment s)
   |void sendSegment(Segment s)
    * lac.mrudp.client.send_seg(self, seg)
   Segment receiveSegmentImpl()
   |Segment receiveSegment()
    * lac.mrudp.client.receiver_fn()
   void sendAndQueueSegment(Segment segment)
    * lac.mrudp.client.send_and_q_seg(seg, self)
   void retransmitSegment(Segment segment)
    * lac.mrudp.client.retransmit_segment(self, seg)
   void connectionOpened()
    * lac.mrudp.connection_opened(self)
   void connectionRefused()
    * ?
   void connectionClosed()
    * ?
   void connectionFailure()
    * lac.mrudp.client.connection_failure(self)
   void connectionReset()
    * ?
   void handleSYNSegment(SYNSegment segment)
    * lac.mrudp.client.handle_syn(self, seg)
   void handleEAKSegment(EAKSegment segment)
    * lac.mrudp.client.handle_eak(self, seg)
   handleSegment(Segment segment)
    * lac.mrudp.client.handle_seg(self, seg)
   void sendAck()
    * lac.mrudp.client.send_ack(self)
   void sendExtendedAck()
    * lac.mrudp.client.end_extended_ack(self)
   void sendSingleAck()
    * lac.mrudp.client.send_single_ack(self)
   void checkAndSetAck(Segment s)
    * lac.mrudp.client.check_and_set_ack(seg)
   void checkAndGetAck(Segment segment)
    * lac.mrudp.check_and_get_ack(seg)
   void checkRecvQueues()
    * lac.mrudp.client.check_recv_qs(self)
   void closeSocket()
    * lac.mrudp.client.close_impl()
   int nextSequenceNumber(int seqn)
    * lac.mrudp.counter.next(seqn)
   int compareSequenceNumbers(int seqn, int aseqn)
    * lac.mrudp.counter.compare_seqn(seqn, aseqn)
   ----- inner classes: -----
   net.rudp.ReliableSocket.Counters
    * lac.mrudp.counter
   net.rudp.ReliableSocketProfile
    * lac.mrudp.config
   net.rudp.ReliableSocket.ReliableSocketThread
    * lac.mrudp.client.receiver_fn
   net.rudp.ReliableSocket.NullSegmentTimerTask
    * lac.mrudp.client.clientskt_timers.nilseg
   net.rudp.ReliableSocket.UIDSegmentTimerTask
    * lac.mrudp.client.clientskt_timers.uidseg
   net.rudp.ReliableSocket.RetransmissionTimerTask
    * lac.mrudp.client.clientskt_timers.retx
   net.rudp.ReliableSocket.CumulativeAckTimerTask
    * lac.mrudp.client.clientskt_timers.cack
   net.rudp.ReliableSocket.KeepAliveTimerTask
    * lac.mrudp.client.clientskt_timers.keepalive
   net.rudp.ReliableSocket.ShutdownHook
    * 

lac.cnclib.sddl.message.Message
 * lac.clientlib.msgs
   
lac.cnclib.sddl.message.ApplicationMessage
 * lac.clientlib.msgs
   ApplicationMessage()
    * lac.clientlib.msgs.new_app()
   Serializable getContentObject()
    * 
   byte[] getContent()
    * msg.content
   void setContentObject(Serializable content)
    * 
   List<String> getTagList()
    * msg.tag_list
   void setTagList(List<String> tagList)
    * msg.tag_list
   void addTag(String tag)
    * msg:add_tag(tag)
   void removeTag(String tag)
    * msg:remove_tag(tag)
   boolean hasTag(String tag)
    * msg:has_tag(tag)
   UUID getSenderID()
    * msg.sender_id
   void setSenderID(UUID senderID)
    * msg.sender_id
   UUID getSenderGatewayID()
    * msg.sender_gw_id
   setSenderGatewayID(UUID senderGatewayID)
    * msg.sender_gw_id
   UUID getRecipientID()
    * msg.recipient_id
   void setRecipientID(UUID recipientID)
    * msg.recipient_id
   UUID getRecipientGatewayID()
    * msg.recipient_gw_id
   void setRecipientGatewayID(UUID recipientGatewayID)
    * msg.recipient_gw_id
   String toString()
    * msg:tostring()
   void setTagList(LinkedList<String> tagList)
    * msg.tag_list
   void setContentClassName(String contentClassName)
    * msg.content_class_name
   long getGatewayLogicalTime()
    * msg.gw_logical_time
   void setGatewayLogicalTime(long gatewayLogicalTime)
    * msg.gw_logical_time
   MSGType getType()
    * msg.type

lac.cnclib.net.mrudp.MrUdpNodeConnection
 * wasHandover
    * node.did_handover
 * wasMandadotyrHandover
    * node.did_mandatory_handover
 * pointsOfAttachment
    * node.poa
 * lac.clientlib.mrudp.node
   MrUdpNodeConnection()
   |MrUdpNodeConnection(UUID senderUUID)
   |MrUdpNodeConnection(ReliableSocketProfile socketProfile)
   |MrUdpNodeConnection(ReliableSocketProfile socketProfile, UUID senderUUID)
   |MrUdpNodeConnection(ReliableSocket socket)
   |MrUdpNodeConnection(ReliableSocket socket, UUID senderUUID)
    * lac.clientlib.mrudp.node.new(scheduler, skt, sender_uuid, cfg, logger)
   UUID getClientUUID()
    * node.sender_uuid
   void setUuid(UUID uuid)
    * node:set_uuid(uuid)
   UUID getUuid()
    * node.uuid
   Socket getSocket()
    * node.skt
   void connect(SocketAddress endpoint)
    * node:connect(host, port)
   void startHandover(boolean mustSwitch, boolean mandatory)
   void disconnect()
   int getNumberOfReconnectionsMade()
    * node.n_reconnections
   boolean updatePointOfAttachment(boolean mustSwitch, boolean mandatoryHandover)
    * lac.clientlib.mrudp.node.update_poa(self, must_switch, mandatory)
   void sendMessage(Message message)
    * node:send_message(msg)
   void addNodeConnectionListener(NodeConnectionListener lis)
   void removeNodeConnectionListener(NodeConnectionListener lis)
   void addExtendedMessageListener(ExtendedMessageListener lis, ExtendedMessage messageType)
   void removeExtendedMessageListener(ExtendedMessageListener lis, ExtendedMessage messageType)
   void addSddlListener(SddlNetworkListener lis)
   void removeSddlListener(SddlNetworkListener lis)
   ----- private: -----
   void sendObject(Serializable message)
   void sendObject(Serializable obj, String className)
    * lac.clientlib.mrudp.send_object(self, obj, name)
   void notifyUnsentMessages()
   void resetSentToUnsent()
   ----- inner classes: -----
   MyReliableSocketStateListener
      void connectionOpened(ReliableSocket sock)
       * lac.clientlib.mrudp.node.my_listener.connection_opened
      void connectionRefused(ReliableSocket sock)
       * lac.clientlib.mrudp.node.my_listener.connection_refused
      void connectionClosed(ReliableSocket sock)
       * lac.clientlib.mrudp.node.my_listener.connection_closed
      void connectionFailure(ReliableSocket sock)
       * lac.clientlib.mrudp.node.my_listener.connection_failure
      void connectionReset(ReliableSocket sock)
       * lac.clientlib.mrudp.node.my_listener.connection_reset
   SentObject
    - n/a
   SendObjectTask
   HandoverTask
    * lac.clientlib.mrudp.node.handover_task_fn
      step
       * node.handover_step
   SenderThread
    * lac.clientlib.mrudp.node.sender_fn
 
