eventmachine 0.12.10-x86-mswin32-60 → 1.0.0.beta.2-x86-mswin32-60

data/java/.classpath

@@ -1,8 +1,8 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry excluding="src/" kind="src" path=""/>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
-	<classpathentry kind="output" path="src"/>
-</classpath>
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry excluding="src/" kind="src" path=""/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
+	<classpathentry kind="output" path="src"/>
+</classpath>

data/java/.project

@@ -1,17 +1,17 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>em_reactor</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>em_reactor</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

data/java/src/com/rubyeventmachine/EmReactor.java

@@ -48,6 +48,7 @@ public class EmReactor {
 	public final int EM_SSL_HANDSHAKE_COMPLETED = 108;
 	public final int EM_SSL_VERIFY = 109;
 	public final int EM_PROXY_TARGET_UNBOUND = 110;
+    public final int EM_PROXY_COMPLETED = 111;
 
 	private Selector mySelector;
 	private TreeMap<Long, ArrayList<Long>> Timers;

data/java/src/com/rubyeventmachine/EmReactorException.java

@@ -1,40 +1,40 @@
-/**
- * $Id$
- * 
- * Author:: Francis Cianfrocca (gmail: blackhedd)
- * Homepage::  http://rubyeventmachine.com
- * Date:: 15 Jul 2007
- * 
- * See EventMachine and EventMachine::Connection for documentation and
- * usage examples.
- * 
- *
- *----------------------------------------------------------------------------
- *
- * Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
- * Gmail: blackhedd
- * 
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of either: 1) the GNU General Public License
- * as published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version; or 2) Ruby's License.
- * 
- * See the file COPYING for complete licensing information.
- *
- *---------------------------------------------------------------------------
- *
- * 
- */
-
-package com.rubyeventmachine;
-
-/**
- * @author francis
- *
- */
-public class EmReactorException extends Exception {
-	static final long serialVersionUID = 0;
-	public EmReactorException (String msg) {
-		super (msg);
-	}
-}
+/**
+ * $Id$
+ * 
+ * Author:: Francis Cianfrocca (gmail: blackhedd)
+ * Homepage::  http://rubyeventmachine.com
+ * Date:: 15 Jul 2007
+ * 
+ * See EventMachine and EventMachine::Connection for documentation and
+ * usage examples.
+ * 
+ *
+ *----------------------------------------------------------------------------
+ *
+ * Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+ * Gmail: blackhedd
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of either: 1) the GNU General Public License
+ * as published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version; or 2) Ruby's License.
+ * 
+ * See the file COPYING for complete licensing information.
+ *
+ *---------------------------------------------------------------------------
+ *
+ * 
+ */
+
+package com.rubyeventmachine;
+
+/**
+ * @author francis
+ *
+ */
+public class EmReactorException extends Exception {
+	static final long serialVersionUID = 0;
+	public EmReactorException (String msg) {
+		super (msg);
+	}
+}

data/lib/em/buftok.rb

@@ -1,138 +1,138 @@
-# BufferedTokenizer - Statefully split input data by a specifiable token
-#
-# Authors:: Tony Arcieri, Martin Emde
-#
-#----------------------------------------------------------------------------
-#
-# Copyright (C) 2006-07 by Tony Arcieri and Martin Emde
-# 
-# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
-#
-#---------------------------------------------------------------------------
-#
-
-# (C)2006 Tony Arcieri, Martin Emde
-# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
-
-# BufferedTokenizer takes a delimiter upon instantiation, or acts line-based
-# by default.  It allows input to be spoon-fed from some outside source which
-# receives arbitrary length datagrams which may-or-may-not contain the token
-# by which entities are delimited.
-#
-# Commonly used to parse lines out of incoming data:
-#
-#  module LineBufferedConnection
-#    def receive_data(data)
-#      (@buffer ||= BufferedTokenizer.new).extract(data).each do |line|
-#        receive_line(line)
-#      end
-#    end
-#  end
-
-class BufferedTokenizer
-  # New BufferedTokenizers will operate on lines delimited by "\n" by default
-  # or allow you to specify any delimiter token you so choose, which will then
-  # be used by String#split to tokenize the input data
-  def initialize(delimiter = "\n", size_limit = nil)
-    # Store the specified delimiter
-    @delimiter = delimiter
-
-    # Store the specified size limitation
-    @size_limit = size_limit
-
-    # The input buffer is stored as an array.  This is by far the most efficient
-    # approach given language constraints (in C a linked list would be a more
-    # appropriate data structure).  Segments of input data are stored in a list
-    # which is only joined when a token is reached, substantially reducing the
-    # number of objects required for the operation.
-    @input = []
-
-    # Size of the input buffer
-    @input_size = 0
-  end
-
-  # Extract takes an arbitrary string of input data and returns an array of
-  # tokenized entities, provided there were any available to extract.  This
-  # makes for easy processing of datagrams using a pattern like:
-  #
-  #   tokenizer.extract(data).map { |entity| Decode(entity) }.each do ...
-  def extract(data)
-    # Extract token-delimited entities from the input string with the split command.
-    # There's a bit of craftiness here with the -1 parameter.  Normally split would
-    # behave no differently regardless of if the token lies at the very end of the 
-    # input buffer or not (i.e. a literal edge case)  Specifying -1 forces split to
-    # return "" in this case, meaning that the last entry in the list represents a
-    # new segment of data where the token has not been encountered
-    entities = data.split @delimiter, -1
-
-    # Check to see if the buffer has exceeded capacity, if we're imposing a limit
-    if @size_limit
-      raise 'input buffer full' if @input_size + entities.first.size > @size_limit
-      @input_size += entities.first.size
-    end
-    
-    # Move the first entry in the resulting array into the input buffer.  It represents
-    # the last segment of a token-delimited entity unless it's the only entry in the list.
-    @input << entities.shift
-
-    # If the resulting array from the split is empty, the token was not encountered
-    # (not even at the end of the buffer).  Since we've encountered no token-delimited
-    # entities this go-around, return an empty array.
-    return [] if entities.empty?
-
-    # At this point, we've hit a token, or potentially multiple tokens.  Now we can bring
-    # together all the data we've buffered from earlier calls without hitting a token,
-    # and add it to our list of discovered entities.
-    entities.unshift @input.join
-
-=begin
-    # Note added by FC, 10Jul07. This paragraph contains a regression. It breaks
-    # empty tokens. Think of the empty line that delimits an HTTP header. It will have
-    # two "\n" delimiters in a row, and this code mishandles the resulting empty token.
-    # It someone figures out how to fix the problem, we can re-enable this code branch.
-    # Multi-character token support.
-    # Split any tokens that were incomplete on the last iteration buf complete now.
-    entities.map! do |e|
-      e.split @delimiter, -1
-    end
-    # Flatten the resulting array.  This has the side effect of removing the empty
-    # entry at the end that was produced by passing -1 to split.  Add it again if
-    # necessary.
-    if (entities[-1] == [])
-      entities.flatten! << []
-    else
-      entities.flatten!
-    end
-=end
-
-    # Now that we've hit a token, joined the input buffer and added it to the entities
-    # list, we can go ahead and clear the input buffer.  All of the segments that were
-    # stored before the join can now be garbage collected.
-    @input.clear
-    
-    # The last entity in the list is not token delimited, however, thanks to the -1
-    # passed to split.  It represents the beginning of a new list of as-yet-untokenized  
-    # data, so we add it to the start of the list.
-    @input << entities.pop
-    
-    # Set the new input buffer size, provided we're keeping track
-    @input_size = @input.first.size if @size_limit
-
-    # Now we're left with the list of extracted token-delimited entities we wanted
-    # in the first place.  Hooray!
-    entities
-  end
-  
-  # Flush the contents of the input buffer, i.e. return the input buffer even though
-  # a token has not yet been encountered
-  def flush
-    buffer = @input.join
-    @input.clear
-    buffer
-  end
-
-  # Is the buffer empty?
-  def empty?
-    @input.empty?
-  end
-end
+# BufferedTokenizer - Statefully split input data by a specifiable token
+#
+# Authors:: Tony Arcieri, Martin Emde
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Tony Arcieri and Martin Emde
+# 
+# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
+#
+#---------------------------------------------------------------------------
+#
+
+# (C)2006 Tony Arcieri, Martin Emde
+# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
+
+# BufferedTokenizer takes a delimiter upon instantiation, or acts line-based
+# by default.  It allows input to be spoon-fed from some outside source which
+# receives arbitrary length datagrams which may-or-may-not contain the token
+# by which entities are delimited.
+#
+# Commonly used to parse lines out of incoming data:
+#
+#  module LineBufferedConnection
+#    def receive_data(data)
+#      (@buffer ||= BufferedTokenizer.new).extract(data).each do |line|
+#        receive_line(line)
+#      end
+#    end
+#  end
+
+class BufferedTokenizer
+  # New BufferedTokenizers will operate on lines delimited by "\n" by default
+  # or allow you to specify any delimiter token you so choose, which will then
+  # be used by String#split to tokenize the input data
+  def initialize(delimiter = "\n", size_limit = nil)
+    # Store the specified delimiter
+    @delimiter = delimiter
+
+    # Store the specified size limitation
+    @size_limit = size_limit
+
+    # The input buffer is stored as an array.  This is by far the most efficient
+    # approach given language constraints (in C a linked list would be a more
+    # appropriate data structure).  Segments of input data are stored in a list
+    # which is only joined when a token is reached, substantially reducing the
+    # number of objects required for the operation.
+    @input = []
+
+    # Size of the input buffer
+    @input_size = 0
+  end
+
+  # Extract takes an arbitrary string of input data and returns an array of
+  # tokenized entities, provided there were any available to extract.  This
+  # makes for easy processing of datagrams using a pattern like:
+  #
+  #   tokenizer.extract(data).map { |entity| Decode(entity) }.each do ...
+  def extract(data)
+    # Extract token-delimited entities from the input string with the split command.
+    # There's a bit of craftiness here with the -1 parameter.  Normally split would
+    # behave no differently regardless of if the token lies at the very end of the 
+    # input buffer or not (i.e. a literal edge case)  Specifying -1 forces split to
+    # return "" in this case, meaning that the last entry in the list represents a
+    # new segment of data where the token has not been encountered
+    entities = data.split @delimiter, -1
+
+    # Check to see if the buffer has exceeded capacity, if we're imposing a limit
+    if @size_limit
+      raise 'input buffer full' if @input_size + entities.first.size > @size_limit
+      @input_size += entities.first.size
+    end
+    
+    # Move the first entry in the resulting array into the input buffer.  It represents
+    # the last segment of a token-delimited entity unless it's the only entry in the list.
+    @input << entities.shift
+
+    # If the resulting array from the split is empty, the token was not encountered
+    # (not even at the end of the buffer).  Since we've encountered no token-delimited
+    # entities this go-around, return an empty array.
+    return [] if entities.empty?
+
+    # At this point, we've hit a token, or potentially multiple tokens.  Now we can bring
+    # together all the data we've buffered from earlier calls without hitting a token,
+    # and add it to our list of discovered entities.
+    entities.unshift @input.join
+
+=begin
+    # Note added by FC, 10Jul07. This paragraph contains a regression. It breaks
+    # empty tokens. Think of the empty line that delimits an HTTP header. It will have
+    # two "\n" delimiters in a row, and this code mishandles the resulting empty token.
+    # It someone figures out how to fix the problem, we can re-enable this code branch.
+    # Multi-character token support.
+    # Split any tokens that were incomplete on the last iteration buf complete now.
+    entities.map! do |e|
+      e.split @delimiter, -1
+    end
+    # Flatten the resulting array.  This has the side effect of removing the empty
+    # entry at the end that was produced by passing -1 to split.  Add it again if
+    # necessary.
+    if (entities[-1] == [])
+      entities.flatten! << []
+    else
+      entities.flatten!
+    end
+=end
+
+    # Now that we've hit a token, joined the input buffer and added it to the entities
+    # list, we can go ahead and clear the input buffer.  All of the segments that were
+    # stored before the join can now be garbage collected.
+    @input.clear
+    
+    # The last entity in the list is not token delimited, however, thanks to the -1
+    # passed to split.  It represents the beginning of a new list of as-yet-untokenized  
+    # data, so we add it to the start of the list.
+    @input << entities.pop
+    
+    # Set the new input buffer size, provided we're keeping track
+    @input_size = @input.first.size if @size_limit
+
+    # Now we're left with the list of extracted token-delimited entities we wanted
+    # in the first place.  Hooray!
+    entities
+  end
+  
+  # Flush the contents of the input buffer, i.e. return the input buffer even though
+  # a token has not yet been encountered
+  def flush
+    buffer = @input.join
+    @input.clear
+    buffer
+  end
+
+  # Is the buffer empty?
+  def empty?
+    @input.empty?
+  end
+end

data/lib/em/callback.rb

@@ -1,26 +1,26 @@
-module EventMachine
-  # Utility method for coercing arguments to an object that responds to #call
-  # Accepts an object and a method name to send to, or a block, or an object
-  # that responds to call.
-  #
-  #  cb = EM.Callback{ |msg| puts(msg) }
-  #  cb.call('hello world')
-  #
-  #  cb = EM.Callback(Object, :puts)
-  #  cb.call('hello world')
-  #
-  #  cb = EM.Callback(proc{ |msg| puts(msg) })
-  #  cb.call('hello world')
-  #
-  def self.Callback(object = nil, method = nil, &blk)
-    if object && method
-      lambda { |*args| object.send method, *args }
-    else
-      if object.respond_to? :call
-        object
-      else 
-        blk || raise(ArgumentError)
-      end
-    end
-  end
+module EventMachine
+  # Utility method for coercing arguments to an object that responds to #call
+  # Accepts an object and a method name to send to, or a block, or an object
+  # that responds to call.
+  #
+  #  cb = EM.Callback{ |msg| puts(msg) }
+  #  cb.call('hello world')
+  #
+  #  cb = EM.Callback(Object, :puts)
+  #  cb.call('hello world')
+  #
+  #  cb = EM.Callback(proc{ |msg| puts(msg) })
+  #  cb.call('hello world')
+  #
+  def self.Callback(object = nil, method = nil, &blk)
+    if object && method
+      lambda { |*args| object.send method, *args }
+    else
+      if object.respond_to? :call
+        object
+      else 
+        blk || raise(ArgumentError)
+      end
+    end
+  end
 end