[Moeng-cvs] Mamura/tests/netobjs NetObjects.rb,1.1,1.2 NetSessions.rb,1.1,1.2

[<b_l...@us...>]

Update of /cvsroot/moeng/Mamura/tests/netobjs
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24868

Modified Files:
	NetObjects.rb NetSessions.rb 
Log Message:
Use closures, and removed some debug messages

Index: NetObjects.rb
===================================================================
RCS file: /cvsroot/moeng/Mamura/tests/netobjs/NetObjects.rb,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** NetObjects.rb	4 Mar 2004 17:47:43 -0000	1.1
--- NetObjects.rb	10 Mar 2004 20:42:59 -0000	1.2
***************
*** 11,23 ****
          @netsession = netsession
          @channel = channel
-         @netsession.on_receive_call(channel, self)
          @next_obj_id = -1
          @client_objs = Array.new
          @server_objs = Array.new
      end
  
      def on_receive(message, from)
!         print("ObjectController received ", message, "\n")
! 
          server_obj = message[0]
          obj_id = message[1]
--- 11,25 ----
          @netsession = netsession
          @channel = channel
          @next_obj_id = -1
          @client_objs = Array.new
          @server_objs = Array.new
+         
+         @netsession.on_receive(channel) { |message, from|
+             self.on_receive(message, from)
+         }
      end
  
      def on_receive(message, from)
!         # Extract information from message
          server_obj = message[0]
          obj_id = message[1]
***************
*** 36,42 ****
              if obj
                  obj.on_receive(mess)
!             elsif @creator
                  obj = NetObjectClient.new(obj_id, from, self)
!                 if @creator.on_create(obj, mess)
                      @client_objs[obj_id] = obj
                  end
--- 38,44 ----
              if obj
                  obj.on_receive(mess)
!             elsif @create_closure
                  obj = NetObjectClient.new(obj_id, from, self)
!                 if @create_closure.call(obj, mess)
                      @client_objs[obj_id] = obj
                  end
***************
*** 45,50 ****
      end
  
!     def on_create_call(creator)
!         @creator = creator
      end
  
--- 47,52 ----
      end
  
!     def on_create(&closure)
!         @create_closure = closure
      end
  
***************
*** 76,79 ****
--- 78,82 ----
  
      def on_receive(message)
+         @handler.on_receive(message) if @handler
      end
  end
***************
*** 102,105 ****
--- 105,109 ----
  
      def on_receive(computer, message)
+         @handler.on_receive(computer, message) if @handler
      end
  end

Index: NetSessions.rb
===================================================================
RCS file: /cvsroot/moeng/Mamura/tests/netobjs/NetSessions.rb,v
retrieving revision 1.1
retrieving revision 1.2
diff -C2 -d -r1.1 -r1.2
*** NetSessions.rb	4 Mar 2004 17:47:43 -0000	1.1
--- NetSessions.rb	10 Mar 2004 20:42:59 -0000	1.2
***************
*** 1,9 ****
  # $Id$
  
  # The network session. This class can function as a server to which clients can
  # connect or it can connect to a server itself, or both.
  
  class NetComputer
!     attr_reader :netsession
  
      def initialize(tcp_socket, netsession)
--- 1,13 ----
  # $Id$
  
+ require 'socket'
+ require 'thread'
+ 
+ 
  # The network session. This class can function as a server to which clients can
  # connect or it can connect to a server itself, or both.
  
  class NetComputer
!     attr_reader :netsession, :tcp_socket
  
      def initialize(tcp_socket, netsession)
***************
*** 15,20 ****
          # message is expected to be an array, but can in theory be any object
          # that can be used with the Marshal module
-         print("Marshalling ", message, " to computer ")
-         print(@tcp_socket.peeraddr[1], " on channel ", channel, "\n")
          @tcp_socket.write(Marshal.dump([channel, message]))
          @tcp_socket.write("\n\n")
--- 19,22 ----
***************
*** 39,43 ****
          @computers = Array.new
          @mutex = Mutex.new
!         @receivers = Hash.new
      end
  
--- 41,45 ----
          @computers = Array.new
          @mutex = Mutex.new
!         @receive_closures = Hash.new
      end
  
***************
*** 53,64 ****
              loop do
                  Thread.start(gs.accept) do |socket|
                      comp = NetComputer.new(socket, self)
-                     puts("New computer connecting")
-                     
-                     # Add to computers array
                      @mutex.synchronize { @computers.push(comp) }
!                     
!                     print(socket, " is accepted\n")
!                     print(@computers.length, " computers connected\n")
  
                      # Wait for messages until computer disconnects
--- 55,66 ----
              loop do
                  Thread.start(gs.accept) do |socket|
+                     # Add a new NetComputer object for connecting computer
                      comp = NetComputer.new(socket, self)
                      @mutex.synchronize { @computers.push(comp) }
! 
!                     # Call the closure if defined
!                     if (@computer_connected_closure)
!                         @computer_connected_closure.call(comp)
!                     end
  
                      # Wait for messages until computer disconnects
***************
*** 72,75 ****
--- 74,82 ----
                      puts("Computer disconnected")
                      @mutex.synchronize { @computers.delete(comp) }
+                     
+                     # Call the closure if defined
+                     if (@computer_disconnected_closure)
+                         @computer_disconnected_closure.call(comp)
+                     end
                  end
              end
***************
*** 84,97 ****
              STDOUT.flush
              socket = TCPSocket.open(host, port)
-             print("Connected from: ", socket.addr.join(":"), "\n")
-             print("Connected to:   ", socket.peeraddr.join(":"), "\n")
              comp = NetComputer.new(socket, self)
              @computers.push(comp)
!             print("Connected to ", @computers.length, " computers\n")
! 
!             print("Listening to server socket\n")
              while incoming = socket.gets("\n\n")
                  message = Marshal.load(incoming)
-                 print(socket.addr[1], " client received ", message, "\n")
                  @mutex.synchronize { @messages.push([message, comp]) }
              end
--- 91,101 ----
              STDOUT.flush
              socket = TCPSocket.open(host, port)
              comp = NetComputer.new(socket, self)
              @computers.push(comp)
!             print("Connected to:   ", socket.peeraddr.join(":"), "\n")
!             
              while incoming = socket.gets("\n\n")
+                 # Unmarshal the message and put it in the messages queue
                  message = Marshal.load(incoming)
                  @mutex.synchronize { @messages.push([message, comp]) }
              end
***************
*** 103,108 ****
      end
  
!     def on_receive_call(channel, receiver)
!         @receivers[channel] = receiver
      end
  
--- 107,116 ----
      end
  
!     def on_receive(channel, &closure)
!         @receive_closures[channel] = closure
!     end
!     
!     def on_computer_connected(&closure)
!         @computer_connected_closure = closure
      end
  
***************
*** 115,120 ****
                  from = message[1]
                  
!                 if @receivers[channel]
!                     @receivers[channel].on_receive(mess, from)
                  end
              }
--- 123,128 ----
                  from = message[1]
                  
!                 if @receive_closures[channel]
!                     @receive_closures[channel].call(mess, from)
                  end
              }