lwes 0.7.0 → 0.8.0pre1

data/ext/{lwes → lwes_ext}/extconf.rb

@@ -2,6 +2,7 @@ require 'net/http'
 require 'mkmf'
 require 'fileutils'
 dir_config('lwes')
+have_func('rb_thread_blocking_region', 'ruby.h')
 
 pwd = File.expand_path(File.dirname(__FILE__))
 v = '0.23.1'
@@ -41,14 +42,14 @@ end
 unless have_library('lwes') && have_header('lwes.h')
   warn "LWES library not found, building locally"
   sub_cd(pwd) do
-    unless test ?r, tgz
+    unless File.readable?(tgz)
       response = fetch(url)
       File.open("#{tgz}.#{$$}.#{rand}.tmp", "wb") do |fp|
         fp.write(response.body)
         File.rename(fp.path, tgz)
       end
     end
-    unless test ?r, "#{inst}/.ok"
+    unless File.readable?("#{inst}/.ok")
       FileUtils.rm_rf(dir)
       system('tar', 'zxf', tgz) or abort "tar failed with #{$?}"
       sub_cd(dir) do

data/ext/lwes_ext/listener.c

@@ -0,0 +1,165 @@
+#include "lwes_ruby.h"
+#include <errno.h>
+
+static void listener_free(void *ptr)
+{
+	struct lwes_listener *listener = ptr;
+
+	if (listener)
+		(void)lwes_listener_destroy(listener);
+}
+
+static struct lwes_listener *listener_ptr(VALUE self)
+{
+	struct lwes_listener *listener = DATA_PTR(self);
+
+	if (listener == NULL)
+		rb_raise(rb_eIOError, "closed listener");
+	return listener;
+}
+
+static void fail(int rc, const char *fn)
+{
+	if (errno)
+		rb_sys_fail(fn);
+	rb_raise(rb_eRuntimeError, "%s failed with: %d", fn, rc);
+}
+
+/*
+ * call-seq:
+ *	listener.close => nil
+ *
+ * Closes the socket used by the LWES::Listener object.  Raises IOError if
+ * already closed.
+ */
+static VALUE listener_close(VALUE self)
+{
+	struct lwes_listener *listener = listener_ptr(self);
+	int err;
+
+	DATA_PTR(self) = NULL;
+	errno = 0;
+	err = lwes_listener_destroy(listener);
+	if (err)
+		fail(err, "lwes_listener_destroy()");
+	return Qnil;
+}
+
+static VALUE listener_alloc(VALUE klass)
+{
+	return Data_Wrap_Struct(klass, NULL, listener_free, NULL);
+}
+
+/*
+ * call-seq:
+ *	listener = LWES::Listener.new(address: "224.1.1.11", port: 12345)
+ *
+ * Binds an LWES listener socket to receive events on.  It takes the following
+ * options:
+ *
+ * - +:address+ is a dotted quad string of an IPv4 address to listen on.
+ * - +:port+ is the port to listen on
+ * - +:iface+ is a dotted quad string of the interface to listen on (optional)
+ */
+static VALUE listener_init(VALUE self, VALUE options)
+{
+	struct lwes_listener *listener;
+	LWES_SHORT_STRING address;
+	LWES_SHORT_STRING iface;
+	LWES_U_INT_32 port;
+	VALUE tmp;
+
+	if (DATA_PTR(self))
+		rb_raise(rb_eRuntimeError,
+		         "initializing already initialized Listener");
+	if (TYPE(options) != T_HASH)
+		rb_raise(rb_eTypeError, "options must be a hash");
+
+	tmp = rb_hash_aref(options, ID2SYM(rb_intern("address")));
+	address = StringValueCStr(tmp);
+
+	tmp = rb_hash_aref(options, ID2SYM(rb_intern("iface")));
+	iface = NIL_P(tmp) ? NULL : StringValueCStr(tmp);
+
+	tmp = rb_hash_aref(options, ID2SYM(rb_intern("port")));
+	port = (LWES_U_INT_32)lwesrb_uint16(tmp);
+
+	listener = lwes_listener_create(address, iface, port);
+	if (listener == NULL) {
+		rb_gc();
+		listener = lwes_listener_create(address, iface, port);
+		if (listener == NULL)
+			rb_raise(rb_eRuntimeError,
+			         "failed to create LWES Listener");
+	}
+
+	DATA_PTR(self) = listener;
+
+	return self;
+}
+
+struct recv_args {
+	struct lwes_listener *listener;
+	struct lwes_event *event;
+	unsigned timeout_ms;
+};
+
+static VALUE recv_event(void *ptr)
+{
+	struct recv_args *a = ptr;
+	int r;
+
+	if (a->timeout_ms == UINT_MAX)
+		r = lwes_listener_recv(a->listener, a->event);
+	else
+		r = lwes_listener_recv_by(a->listener, a->event, a->timeout_ms);
+	return (VALUE)r;
+}
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+/*
+ * call-seq:
+ *	listener.recv => LWES::Event
+ *	listener.recv(timeout_ms) => LWES::Event or nil
+ *
+ * Receives and returns one LWES::Event from the network.
+ * An optional timeout (in milliseconds) may be specified and cause this
+ * to return +nil+ on timeout.  This method is only available under Ruby 1.9.
+ */
+static VALUE listener_recv(int argc, VALUE *argv, VALUE self)
+{
+	struct recv_args args;
+	VALUE timeout;
+	int r, saved_errno;
+
+	rb_scan_args(argc, argv, "01", &timeout);
+
+	args.listener = listener_ptr(self);
+	args.event = lwes_event_create_no_name(NULL);
+	args.timeout_ms = NIL_P(timeout) ? UINT_MAX : NUM2UINT(timeout);
+
+	saved_errno = errno = 0;
+	r = (int)rb_thread_blocking_region(recv_event, &args, RUBY_UBF_IO, 0);
+	if (r >= 0)
+		return lwesrb_wrap_event(cLWES_Event, args.event);
+	saved_errno = errno;
+	(void)lwes_event_destroy(args.event);
+	if (r == -2 && ! NIL_P(timeout))
+		return Qnil;
+	errno = saved_errno;
+	fail(r, "lwes_listener_recv(_by)");
+	return Qnil;
+}
+#endif /* HAVE_RB_THREAD_BLOCKING_REGION */
+
+void lwesrb_init_listener(void)
+{
+	VALUE mLWES = rb_define_module("LWES");
+	VALUE cListener = rb_define_class_under(mLWES, "Listener", rb_cObject);
+	rb_define_alloc_func(cListener, listener_alloc);
+	rb_define_private_method(cListener, "initialize", listener_init, 1);
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+	rb_define_method(cListener, "recv", listener_recv, -1);
+#endif
+	rb_define_method(cListener, "close", listener_close, 0);
+}

data/ext/{lwes → lwes_ext}/lwes.c

@@ -23,4 +23,5 @@ void Init_lwes_ext(void)
 	lwesrb_init_emitter();
 	lwesrb_init_type_db();
 	lwesrb_init_event();
+	lwesrb_init_listener();
 }

data/ext/{lwes → lwes_ext}/lwes_ruby.h

@@ -21,6 +21,10 @@ void lwesrb_init_numeric(void);
 
 void lwesrb_init_event(void);
 
+void lwesrb_init_listener(void);
+
+VALUE lwesrb_wrap_event(VALUE klass, struct lwes_event *e);
+
 void lwesrb_dump_type(LWES_BYTE type, LWES_BYTE_P buf, size_t *off);
 
 void lwesrb_dump_num(LWES_BYTE type, VALUE val, LWES_BYTE_P buf, size_t *off);
@@ -37,17 +41,20 @@ void lwesrb_dump_num_ary(VALUE array, LWES_BYTE_P buf, size_t *off);
 #  define RARRAY_LEN(s) (RARRAY(s)->len)
 #endif
 
-#ifndef RSTRUCT_PTR
-#  define RSTRUCT_PTR(s) (RSTRUCT(s)->ptr)
-#  define RSTRUCT_LEN(s) (RSTRUCT(s)->len)
-#endif
-
 #define RAISE_INSPECT(v) RSTRING_PTR(raise_inspect = rb_inspect(v))
 
 extern VALUE cLWES_Event;
 
 struct lwes_event * lwesrb_get_event(VALUE self);
 
-VALUE lwesrb_event_to_hash(struct lwes_event *e);
+LWES_U_INT_16 lwesrb_uint16(VALUE val);
+LWES_INT_16 lwesrb_int16(VALUE val);
+LWES_U_INT_32 lwesrb_uint32(VALUE val);
+LWES_INT_32 lwesrb_int32(VALUE val);
+LWES_U_INT_64 lwesrb_uint64(VALUE val);
+/* NUM2LL can raise RangeError */
+#define lwesrb_int64(VAL) (LWES_INT_64)NUM2LL((VAL))
+LWES_IP_ADDR lwesrb_ip_addr(VALUE val);
+LWES_BOOLEAN lwesrb_boolean(VALUE val);
 
 #endif /* LWES_RUBY_H */

data/ext/{lwes → lwes_ext}/numeric.c

@@ -8,110 +8,46 @@ static ID
   sym_ip_addr;
 static ID id_to_i;
 
-void lwesrb_dump_type(LWES_BYTE type, LWES_BYTE_P buf, size_t *off)
-{
-	if (marshall_BYTE(type, buf, MAX_MSG_SIZE, off) > 0)
-		return;
-	rb_raise(rb_eRuntimeError, "failed to dump type=%02x", (unsigned)type);
-}
-
 static int dump_uint16(VALUE val, LWES_BYTE_P buf, size_t *off)
 {
-	int32_t tmp = NUM2INT(val);
-
-	if (tmp < 0)
-		rb_raise(rb_eRangeError, ":uint16 negative: %d", tmp);
-	if (tmp > UINT16_MAX)
-		rb_raise(rb_eRangeError, ":uint16 too large: %d", tmp);
-
 	lwesrb_dump_type(LWES_U_INT_16_TOKEN, buf, off);
-	return marshall_U_INT_16((LWES_U_INT_16)tmp, buf, MAX_MSG_SIZE, off);
+	return marshall_U_INT_16(lwesrb_uint16(val), buf, MAX_MSG_SIZE, off);
 }
 
 static int dump_int16(VALUE val, LWES_BYTE_P buf, size_t *off)
 {
-	int32_t tmp = NUM2INT(val);
-
-	if (tmp > INT16_MAX)
-		rb_raise(rb_eRangeError, ":int16 too large: %i", tmp);
-	if (tmp < INT16_MIN)
-		rb_raise(rb_eRangeError, ":int16 too small: %i", tmp);
-
 	lwesrb_dump_type(LWES_INT_16_TOKEN, buf, off);
-	return marshall_INT_16((LWES_INT_16)tmp, buf, MAX_MSG_SIZE, off);
+	return marshall_INT_16(lwesrb_int16(val), buf, MAX_MSG_SIZE, off);
 }
 
 static int dump_uint32(VALUE val, LWES_BYTE_P buf, size_t *off)
 {
-	LONG_LONG tmp = NUM2LL(val);
-
-	if (tmp < 0)
-		rb_raise(rb_eRangeError, ":uint32 negative: %lli", tmp);
-	if (tmp > UINT32_MAX)
-		rb_raise(rb_eRangeError, ":uint32 too large: %lli", tmp);
-
 	lwesrb_dump_type(LWES_U_INT_32_TOKEN, buf, off);
-	return marshall_U_INT_32((LWES_U_INT_32)tmp, buf, MAX_MSG_SIZE, off);
+	return marshall_U_INT_32(lwesrb_uint32(val), buf, MAX_MSG_SIZE, off);
 }
 
 static int dump_int32(VALUE val, LWES_BYTE_P buf, size_t *off)
 {
-	LONG_LONG tmp = NUM2LL(val);
-
-	if (tmp > INT32_MAX)
-		rb_raise(rb_eRangeError, ":int32 too large: %lli", tmp);
-	if (tmp < INT32_MIN)
-		rb_raise(rb_eRangeError, ":int32 too small: %lli", tmp);
-
 	lwesrb_dump_type(LWES_INT_32_TOKEN, buf, off);
-	return marshall_INT_32((LWES_INT_32)tmp, buf, MAX_MSG_SIZE, off);
+	return marshall_INT_32(lwesrb_int32(val), buf, MAX_MSG_SIZE, off);
 }
 
 static int dump_uint64(VALUE val, LWES_BYTE_P buf, size_t *off)
 {
-	unsigned LONG_LONG tmp = NUM2ULL(val); /* can raise RangeError */
-	ID type = TYPE(val);
-
-	if ((type == T_FIXNUM && FIX2LONG(val) < 0) ||
-	    (type == T_BIGNUM && RTEST(rb_funcall(val, '<', 1, INT2FIX(0))))) {
-		volatile VALUE raise_inspect;
-
-		rb_raise(rb_eRangeError, ":uint64 negative: %s",
-		         RAISE_INSPECT(val));
-	}
-
 	lwesrb_dump_type(LWES_U_INT_64_TOKEN, buf, off);
-	return marshall_U_INT_64((LWES_U_INT_64)tmp, buf, MAX_MSG_SIZE, off);
+	return marshall_U_INT_64(lwesrb_uint64(val), buf, MAX_MSG_SIZE, off);
 }
 
 static int dump_int64(VALUE val, LWES_BYTE_P buf, size_t *off)
 {
-	LONG_LONG tmp = NUM2LL(val); /* can raise RangeError */
-
 	lwesrb_dump_type(LWES_INT_64_TOKEN, buf, off);
-	return marshall_INT_64((LWES_INT_64)tmp, buf, MAX_MSG_SIZE, off);
+	return marshall_INT_64(lwesrb_int64(val), buf, MAX_MSG_SIZE, off);
 }
 
 static int dump_ip_addr(VALUE val, LWES_BYTE_P buf, size_t *off)
 {
-	LWES_IP_ADDR addr;
-	volatile VALUE raise_inspect;
-
-	switch (TYPE(val)) {
-	case T_STRING:
-		addr.s_addr = inet_addr(RSTRING_PTR(val));
-		break;
-	case T_FIXNUM:
-	case T_BIGNUM:
-		addr.s_addr = htonl(NUM2UINT(val));
-		break;
-	default:
-		rb_raise(rb_eTypeError,
-		         ":ip_addr address must be String or Integer: %s",
-		         RAISE_INSPECT(val));
-	}
 	lwesrb_dump_type(LWES_IP_ADDR_TOKEN, buf, off);
-	return marshall_IP_ADDR(addr, buf, MAX_MSG_SIZE, off);
+	return marshall_IP_ADDR(lwesrb_ip_addr(val), buf, MAX_MSG_SIZE, off);
 }
 
 /* simple type => function dispatch map */

data/ext/lwes_ext/type_conv.c

@@ -0,0 +1,99 @@
+#include "lwes_ruby.h"
+
+void lwesrb_dump_type(LWES_BYTE type, LWES_BYTE_P buf, size_t *off)
+{
+	if (marshall_BYTE(type, buf, MAX_MSG_SIZE, off) > 0)
+		return;
+	rb_raise(rb_eRuntimeError, "failed to dump type=%02x", (unsigned)type);
+}
+
+LWES_U_INT_16 lwesrb_uint16(VALUE val)
+{
+	int32_t tmp = NUM2INT(val);
+
+	if (tmp != (LWES_U_INT_16)tmp) {
+		const char *s = tmp < 0 ? "negative" : "too big";
+		rb_raise(rb_eRangeError, ":uint16 %s: %d", s, tmp);
+	}
+	return (LWES_U_INT_16)tmp;
+}
+
+LWES_INT_16 lwesrb_int16(VALUE val)
+{
+	int32_t tmp = NUM2INT(val);
+
+	if (tmp != (LWES_INT_16)tmp) {
+		const char *s = tmp < 0 ? "small" : "big";
+		rb_raise(rb_eRangeError, ":int16 too %s: %d", s, tmp);
+	}
+	return (LWES_INT_16)tmp;
+}
+
+LWES_U_INT_32 lwesrb_uint32(VALUE val)
+{
+	LONG_LONG tmp = NUM2LL(val);
+
+	if (tmp != (LWES_U_INT_32)tmp) {
+		const char *s = tmp < 0 ? "negative" : "too big";
+		rb_raise(rb_eRangeError, ":uint32 %s: %lli", s, tmp);
+	}
+	return (LWES_U_INT_32)tmp;
+}
+
+LWES_INT_32 lwesrb_int32(VALUE val)
+{
+	LONG_LONG tmp = NUM2LL(val);
+
+	if (tmp != (LWES_INT_32)tmp) {
+		const char *s = tmp < 0 ? "small" : "big";
+		rb_raise(rb_eRangeError, ":int32 too %s: %lli", s, tmp);
+	}
+	return (LWES_INT_32)tmp;
+}
+
+LWES_U_INT_64 lwesrb_uint64(VALUE val)
+{
+	unsigned LONG_LONG tmp = NUM2ULL(val); /* can raise RangeError */
+	ID type = TYPE(val);
+
+	if ((type == T_FIXNUM && FIX2LONG(val) < 0) ||
+	    (type == T_BIGNUM && RTEST(rb_funcall(val, '<', 1, INT2FIX(0))))) {
+		volatile VALUE raise_inspect;
+
+		rb_raise(rb_eRangeError, ":uint64 negative: %s",
+		         RAISE_INSPECT(val));
+	}
+	return (LWES_U_INT_64)tmp;
+}
+
+LWES_IP_ADDR lwesrb_ip_addr(VALUE val)
+{
+	LWES_IP_ADDR addr;
+	volatile VALUE raise_inspect;
+
+	switch (TYPE(val)) {
+	case T_STRING:
+		addr.s_addr = inet_addr(StringValueCStr(val));
+		break;
+	case T_FIXNUM:
+	case T_BIGNUM:
+		addr.s_addr = htonl(NUM2UINT(val));
+		break;
+	default:
+		rb_raise(rb_eTypeError,
+		         ":ip_addr address must be String or Integer: %s",
+		         RAISE_INSPECT(val));
+	}
+
+	return addr;
+}
+
+LWES_BOOLEAN lwesrb_boolean(VALUE val)
+{
+	if (val == Qtrue) return TRUE;
+        if (val != Qfalse) {
+		volatile VALUE raise_inspect;
+		rb_raise(rb_eTypeError, "non-boolean: %s", RAISE_INSPECT(val));
+	}
+	return FALSE;
+}

data/ext/{lwes → lwes_ext}/type_db.c

@@ -2,48 +2,38 @@
 
 VALUE cLWES_TypeDB;
 
-struct _tdb {
-	struct lwes_event_type_db *db;
-};
-
 static void tdb_free(void *ptr)
 {
-	struct _tdb *tdb = ptr;
+	struct lwes_event_type_db *db = ptr;
 
-	if (tdb->db)
-		lwes_event_type_db_destroy(tdb->db);
-	xfree(ptr);
+	if (db)
+		lwes_event_type_db_destroy(db);
 }
 
 static VALUE tdb_alloc(VALUE klass)
 {
-	struct _tdb *tdb;
-
-	return Data_Make_Struct(klass, struct _tdb, NULL, tdb_free, tdb);
+	return Data_Wrap_Struct(klass, NULL, tdb_free, NULL);
 }
 
 static VALUE tdb_init(VALUE self, VALUE path)
 {
-	struct _tdb *tdb;
+	struct lwes_event_type_db *db = DATA_PTR(self);
 	int gc_retry = 1;
+	char *cpath = StringValueCStr(path);
 
-	if (TYPE(path) != T_STRING)
-		rb_raise(rb_eArgError, "path must be a string");
-
-	Data_Get_Struct(self, struct _tdb, tdb);
-	if (tdb->db)
+	if (db)
 		rb_raise(rb_eRuntimeError, "ESF already initialized");
 retry:
-	tdb->db = lwes_event_type_db_create(RSTRING_PTR(path));
-	if (!tdb->db) {
+	db = lwes_event_type_db_create(cpath);
+	if (!db) {
 		if (--gc_retry == 0) {
 			rb_gc();
 			goto retry;
 		}
 		rb_raise(rb_eRuntimeError,
-		         "failed to create type DB for LWES file %s",
-		         RSTRING_PTR(path));
+		         "failed to create type DB for LWES file %s", cpath);
 	}
+	DATA_PTR(self) = db;
 
 	return Qnil;
 }
@@ -100,28 +90,26 @@ static VALUE event_def_ary(struct lwes_hash *hash)
 
 struct lwes_event_type_db * lwesrb_get_type_db(VALUE self)
 {
-	struct _tdb *tdb;
+	struct lwes_event_type_db *db = DATA_PTR(self);
 
-	Data_Get_Struct(self, struct _tdb, tdb);
-	if (! tdb->db) {
+	if (!db) {
 		volatile VALUE raise_inspect;
 		rb_raise(rb_eRuntimeError,
 			 "couldn't get lwes_type_db from %s",
 			 RAISE_INSPECT(self));
 	}
-	return tdb->db;
+	return db;
 }
 
 static VALUE tdb_to_hash(VALUE self)
 {
-	struct _tdb *tdb;
+	struct lwes_event_type_db *db = DATA_PTR(self);
 	VALUE rv = rb_hash_new();
 	struct lwes_hash *events;
 	struct lwes_hash_enumeration e;
 
-	Data_Get_Struct(self, struct _tdb, tdb);
-	assert(tdb->db && tdb->db->events && "tdb not initialized");
-	events = tdb->db->events;
+	assert(db && db->events && "tdb not initialized");
+	events = db->events;
 
 	if (!lwes_hash_keys(events, &e))
 		rb_raise(rb_eRuntimeError, "couldn't get type_db events");
@@ -151,7 +139,7 @@ void lwesrb_init_type_db(void)
 {
 	VALUE mLWES = rb_define_module("LWES");
 	cLWES_TypeDB = rb_define_class_under(mLWES, "TypeDB", rb_cObject);
-	rb_define_method(cLWES_TypeDB, "initialize", tdb_init, 1);
+	rb_define_private_method(cLWES_TypeDB, "initialize", tdb_init, 1);
 	rb_define_method(cLWES_TypeDB, "to_hash", tdb_to_hash, 0);
 	rb_define_alloc_func(cLWES_TypeDB, tdb_alloc);
 }

data/lib/lwes/class_maker.rb

@@ -0,0 +1,50 @@
+# :stopdoc:
+# internal class
+module LWES::ClassMaker
+  def type_db(options)
+    options[:db] || begin
+      file = options[:file] or
+        raise ArgumentError, "TypeDB :db or ESF :file missing"
+      File.readable?(file) or
+        raise ArgumentError, "file #{file.inspect} not readable"
+      LWES::TypeDB.new(file)
+    end
+  end
+
+  def class_for(options, dump)
+    klass = options[:class] || begin
+      # make it easier to deal with single event files
+      events = (dump.keys -  [ :MetaEventInfo ])
+      events.size > 1 and
+          raise RuntimeError,
+                "multiple event defs available: #{events.inspect}\n" \
+                "pick one with :class"
+      events.first
+    end
+    name = options[:name] || klass.to_s
+    event_def = dump[name.to_sym] or
+      raise RuntimeError, "#{name.inspect} not defined in #{file}"
+    [ klass, name, event_def ]
+  end
+
+  def set_constants(tmp, db, klass, name, options)
+    tmp.const_set :TYPE_DB, db
+    tmp.const_set :NAME, name.to_s.dup.freeze
+    defaults = options[:defaults] || {}
+    tmp.const_set :DEFAULTS, defaults.dup
+    parent = options.include?(:parent) ? options[:parent] : Object
+    parent or return
+    components = klass.to_s.split(/::/)
+    components.each_with_index do |component, i|
+      if i == (components.size - 1)
+        tmp = parent.const_set(component, tmp)
+      else
+        parent = begin
+          parent.const_get(component)
+        rescue NameError
+          parent.const_set component, Module.new
+        end
+      end
+    end
+  end
+end

data/lib/lwes/event.rb

@@ -1,7 +1,57 @@
-# this class is incomplete, but will eventually be subclassable
-# like Struct in Ruby
+# Used for mapping LWES events in in an ESF file to a Ruby object.
+# LWES::Event-derived classes are more memory efficient if your event
+# definitions have many unused fields.
+#
+# LWES::TypeDB.create_classes! with +:sparse+ set to +true+
 class LWES::Event
+  SYM2ATTR = Hash.new { |h,k| h[k] = k.to_s.freeze } # :nodoc:
+
+  # used to cache classes for LWES::Event.parse
+  CLASSES = {} # :nodoc:
+  extend LWES::ClassMaker
+
+  def self.subclass(options, &block)
+    db = type_db(options)
+    dump = db.to_hash
+    klass, name, event_def = class_for(options, dump)
+    tmp = Class.new(self)
+    set_constants(tmp, db, klass, name, options)
+    tmp.class_eval(&block) if block_given?
+
+    meta = dump[:MetaEventInfo] || []
+    methods = meta + event_def
+    methods = methods.inject("") do |str, (k,_)|
+      str << "def #{k}; self[:#{k}]; end\n"
+      str << "def #{k}= val; self[:#{k}] = val; end\n"
+    end
+    methods << "def initialize(src = nil); merge!(DEFAULTS); super; end\n"
+    tmp.class_eval methods
+    CLASSES[name] = tmp
+  end
+
   def inspect
-    "#<#{self.class}:#{to_hash}>"
+    klass = self.class
+    if LWES::Event == klass
+      "#<#{klass}:#{to_hash.inspect}>"
+    else
+      "#<#{klass}(event:#{klass.const_get(:NAME)}):#{to_hash.inspect}>"
+    end
+  end
+
+  def merge! src
+    src.to_hash.each { |k,v| self[k] = v }
+    self
+  end
+
+  alias_method :initialize_copy, :merge!
+
+  def merge src
+    dup.merge! src
+  end
+
+private
+
+  def initialize(src = nil)
+    src and merge! src
   end
 end

data/lib/lwes/listener.rb

@@ -0,0 +1,26 @@
+#
+# This class is only supported on Ruby 1.9
+#
+#   listener = LWES::Listener.new :address => "224.1.1.11", :port => 12345
+#   listener.each do |event|
+#     p event
+#   end
+#
+class LWES::Listener
+
+  # we disallow dup-ing objects since GC could double-free otherwise
+  def dup
+    self
+  end
+
+  alias clone dup
+
+  # process each LWES::Event object as it is received
+  def each
+    begin
+      yield recv
+    rescue Errno::EINTR
+    end while true
+    self
+  end
+end