lwes 0.7.0 → 0.8.0pre1

data/.gitignore

@@ -0,0 +1,4 @@
+*.o
+*.so
+*.log
+/tmp

data/ChangeLog

@@ -1,3 +1,7 @@
+Version 0.8.0pre1 (erik-s-chang)
+  * preliminary LWES::Listener support for Ruby 1.9 users
+  * LWES::Event enhancements and cleanups
+
 Version 0.7.0 (erik-s-chang)
   * rely on lwes-c 0.23.1 instead of patching 0.22.3
 

data/README

@@ -1,7 +1,7 @@
-= LWES - Light Weight Event System API for Ruby
+= LWES - Light Weight Event System bindings for Ruby
 
 * http://www.lwes.org
-* http://sourceforge.net/projects/lwes
+* git://rubyforge.org/lwes.git
 
 == DESCRIPTION:
 
@@ -23,13 +23,16 @@ may support listening and journaling capabilities as time allows.
 
 == SUPPORT:
 
-See the SourceForge project.
+Email the author: mailto:erik.s.chang@gmail.com and expect a response
+within 72 hours.
 
 == DEVELOPMENT:
 
-Our SVN repository is here:
+Our git repository is here:
 
-  https://lwes.svn.sourceforge.net/svnroot/lwes/lwes-ruby
+  git clone git://rubyforge.org/lwes.git
+
+Email pull requests or patches to the the author mailto:erik.s.chang@gmail.com
 
 == INSTALL:
 
@@ -40,42 +43,9 @@ gem.
 
   gem install lwes
 
-== SYNOPSIS:
-
-  require 'lwes'
-
-  # create an Emitter which may be used for the lifetime of your process
-  emitter = LWES::Emitter.new(:address => '224.1.1.11',
-                              :port => 12345,
-                              :heartbeat => 30, # nil to disable
-                              :ttl => 1) # nil for default TTL(3)
-
-  # parse your ESF file at startup, the example below assumes you
-  # have "Event1" and "Event2" defined in your ESF file:
-  type_db = LWES::TypeDB.new("my_events.esf")
-
-  # create classes to use, by default and to encourage DRY-ness,
-  # we map each event in the ESF file to a class
-  # Optionally, you may specify :parent => module/namespace
-  type_db.create_classes! :parent => MyApp
-
-  # inside your application, you may now do this to slowly build up
-  # fields for the event
-  my_event = MyApp::Event1.new
-  my_event.started = Time.now.to_i
-  my_event.remote_addr = "192.168.0.1"
-  # ...do a lot of stuff here in between...
-  my_event.field1 = value1
-  my_event.field2 = value2
-  my_event.field3 = value3
-  my_event.finished = Time.now.to_i
-  emitter << my_event
-
-  # Alternatively, if you know ahead of time all the fields you want to
-  # set for an event, you can emit an event in one step:
-
-  emitter.emit MyApp::Event2, :field1 => value1, :field2 => value2 # ...
+== SYNOPSIS
 
+See link:LWES.html
 
 == NON-ESF USERS:
 

data/Rakefile

@@ -1,21 +1,24 @@
 require 'rake/testtask'
+task :default => :test
 
 desc "run all tests"
 task :test => %w(test:unit)
 
 desc "run unit tests"
-Rake::TestTask.new('test:unit') do |t|
-  t.libs << "ext/lwes"
+Rake::TestTask.new('test:unit' => :compile) do |t|
+  t.libs << "ext/lwes_ext"
   t.test_files = FileList['test/unit/test_*.rb']
   t.warning = true
   t.verbose = true if ENV["VERBOSE"].to_i > 0
 end
+require "rake/extensiontask"
+Rake::ExtensionTask.new("lwes_ext")
 
-gem 'rdoc', '>= 2.4.3'
+gem 'rdoc', '>= 3.5.3'
 require 'rdoc/task'
 RDoc::Task.new do |rd|
   rd.main = "README"
-  rd.rdoc_files.include("README", "lib/**/*.rb", "ext/lwes/*.c")
+  rd.rdoc_files.include("README", "lib/**/*.rb", "ext/lwes_ext/*.c")
 end
 
 desc "update website"

data/ext/lwes_ext/.gitignore

@@ -0,0 +1,2 @@
+Makefile
+/.inst

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

@@ -3,36 +3,23 @@
 static VALUE ENC; /* LWES_ENCODING */
 static ID id_TYPE_DB, id_TYPE_LIST, id_NAME, id_HAVE_ENCODING;
 static ID id_new, id_enc, id_size;
-static ID sym_enc;
+static VALUE sym_enc;
 
-static void dump_name(VALUE name, LWES_BYTE_P buf, size_t *off)
+static void dump_name(char *name, LWES_BYTE_P buf, size_t *off)
 {
-	char *s = RSTRING_PTR(name);
-
-	if (marshall_SHORT_STRING(s, buf, MAX_MSG_SIZE, off) > 0)
+	if (marshall_SHORT_STRING(name, buf, MAX_MSG_SIZE, off) > 0)
 		return;
-	rb_raise(rb_eRuntimeError, "failed to dump name=%s", s);
+	rb_raise(rb_eRuntimeError, "failed to dump name=%s", name);
 }
 
-static int dump_bool(VALUE name, VALUE val, LWES_BYTE_P buf, size_t *off)
+static int dump_bool(char *name, VALUE val, LWES_BYTE_P buf, size_t *off)
 {
-	LWES_BOOLEAN tmp = FALSE;
-
-	if (val == Qtrue) {
-		tmp = TRUE;
-	} else if (val != Qfalse) {
-		volatile VALUE raise_inspect;
-
-		rb_raise(rb_eTypeError, "non-boolean set for %s: %s",
-			 RSTRING_PTR(name),
-			 RAISE_INSPECT(val));
-	}
 	dump_name(name, buf, off);
 	lwesrb_dump_type(LWES_BOOLEAN_TOKEN, buf, off);
-	return marshall_BOOLEAN(tmp, buf, MAX_MSG_SIZE, off);
+	return marshall_BOOLEAN(lwesrb_boolean(val), buf, MAX_MSG_SIZE, off);
 }
 
-static int dump_string(VALUE name, VALUE val, LWES_BYTE_P buf, size_t *off)
+static int dump_string(char *name, VALUE val, LWES_BYTE_P buf, size_t *off)
 {
 	char *dst;
 
@@ -41,7 +28,7 @@ static int dump_string(VALUE name, VALUE val, LWES_BYTE_P buf, size_t *off)
 	case T_FIXNUM:
 		val = rb_obj_as_string(val);
 	}
-	dst = StringValuePtr(val);
+	dst = StringValueCStr(val);
 
 	dump_name(name, buf, off);
 	lwesrb_dump_type(LWES_STRING_TOKEN, buf, off);
@@ -50,7 +37,7 @@ static int dump_string(VALUE name, VALUE val, LWES_BYTE_P buf, size_t *off)
 
 static void dump_enc(VALUE enc, LWES_BYTE_P buf, size_t *off)
 {
-	dump_name(ENC, buf, off);
+	dump_name((char *)LWES_ENCODING, buf, off);
 	lwesrb_dump_num(LWES_INT_16_TOKEN, enc, buf, off);
 }
 
@@ -106,6 +93,11 @@ static VALUE rle_alloc(VALUE klass)
 	                        NULL, rle_free, rle);
 }
 
+struct hash_memo {
+	size_t off;
+	LWES_BYTE_P buf;
+};
+
 /*
  * kv - Array:
  *   key => String,
@@ -117,12 +109,14 @@ static VALUE rle_alloc(VALUE klass)
 static VALUE event_hash_iter_i(VALUE kv, VALUE memo)
 {
 	volatile VALUE raise_inspect;
-	VALUE *tmp = (VALUE *)memo;
+	struct hash_memo *hash_memo = (struct hash_memo *)NUM2ULONG(memo);
 	VALUE val;
 	VALUE name;
+	char *attr_name;
 	int rv = 0;
-	LWES_BYTE_P buf = (LWES_BYTE_P)tmp[0];
-	size_t *off = (size_t *)tmp[1];
+	LWES_BYTE_P buf = hash_memo->buf;
+	size_t *off = &hash_memo->off;
+	VALUE *tmp;
 
 	if (TYPE(kv) != T_ARRAY || RARRAY_LEN(kv) != 2)
 		rb_raise(rb_eTypeError,
@@ -133,8 +127,9 @@ static VALUE event_hash_iter_i(VALUE kv, VALUE memo)
 	if (name == sym_enc) return Qnil; /* already dumped first */
 
 	name = rb_obj_as_string(name);
+	attr_name = StringValueCStr(name);
 
-	if (strcmp(RSTRING_PTR(name), LWES_ENCODING) == 0)
+	if (strcmp(attr_name, LWES_ENCODING) == 0)
 		return Qnil;
 
 	val = tmp[1];
@@ -142,14 +137,14 @@ static VALUE event_hash_iter_i(VALUE kv, VALUE memo)
 	switch (TYPE(val)) {
 	case T_TRUE:
 	case T_FALSE:
-		rv = dump_bool(name, val, buf, off);
+		rv = dump_bool(attr_name, val, buf, off);
 		break;
 	case T_ARRAY:
-		dump_name(name, buf, off);
+		dump_name(attr_name, buf, off);
 		lwesrb_dump_num_ary(val, buf, off);
 		return Qnil;
 	case T_STRING:
-		rv = dump_string(name, val, buf, off);
+		rv = dump_string(attr_name, val, buf, off);
 		break;
 	}
 
@@ -157,31 +152,31 @@ static VALUE event_hash_iter_i(VALUE kv, VALUE memo)
 		return Qnil;
 
 	rb_raise(rb_eArgError, "unhandled type %s=%s",
-		 RSTRING_PTR(name), RAISE_INSPECT(val));
+		 attr_name, RAISE_INSPECT(val));
 	return Qfalse;
 }
 
 static VALUE emit_hash(VALUE self, VALUE name, VALUE event)
 {
 	struct _rb_lwes_emitter *rle = _rle(self);
-	LWES_BYTE_P buf = rle->emitter->buffer;
-	VALUE tmp[2];
-	size_t off = 0;
+	struct hash_memo hash_memo;
+	LWES_BYTE_P buf;
+	size_t *off;
+	VALUE memo = ULONG2NUM((unsigned long)&hash_memo);
 	VALUE enc;
-	int size = NUM2INT(rb_funcall(event, id_size, 0, 0));
+	LWES_U_INT_16 size = lwesrb_uint16(rb_funcall(event, id_size, 0, 0));
 	int rv;
+	char *event_name = StringValueCStr(name);
 
-	tmp[0] = (VALUE)buf;
-	tmp[1] = (VALUE)&off;
-
-	if (size < 0 || size > UINT16_MAX)
-		rb_raise(rb_eRangeError, "hash size out of uint16 range");
+	buf = hash_memo.buf = rle->emitter->buffer;
+	hash_memo.off = 0;
+	off = &hash_memo.off;
 
 	/* event name first */
-	dump_name(name, buf, &off);
+	dump_name(event_name, buf, off);
 
 	/* number of attributes second */
-	rv = marshall_U_INT_16((LWES_U_INT_16)size, buf, MAX_MSG_SIZE, &off);
+	rv = marshall_U_INT_16(size, buf, MAX_MSG_SIZE, off);
 	if (rv <= 0)
 		rb_raise(rb_eRuntimeError, "failed to dump num_attrs");
 
@@ -190,12 +185,12 @@ static VALUE emit_hash(VALUE self, VALUE name, VALUE event)
 	if (NIL_P(enc))
 		enc = rb_hash_aref(event, ENC);
 	if (! NIL_P(enc))
-		dump_enc(enc, buf, &off);
+		dump_enc(enc, buf, off);
 
 	/* the rest of the fields */
-	rb_iterate(rb_each, event, event_hash_iter_i, (VALUE)&tmp);
+	rb_iterate(rb_each, event, event_hash_iter_i, memo);
 
-	if (lwes_emitter_emit_bytes(rle->emitter, buf, off) < 0)
+	if (lwes_emitter_emit_bytes(rle->emitter, buf, *off) < 0)
 		rb_raise(rb_eRuntimeError, "failed to emit event");
 
 	return event;
@@ -203,7 +198,7 @@ static VALUE emit_hash(VALUE self, VALUE name, VALUE event)
 
 static void
 marshal_field(
-	VALUE name,
+	char *name,
 	LWES_TYPE type,
 	VALUE val,
 	LWES_BYTE_P buf,
@@ -227,7 +222,7 @@ marshal_field(
 	}
 
 	rb_raise(rb_eRuntimeError, "failed to set %s=%s",
-		 RSTRING_PTR(name), RAISE_INSPECT(val));
+		 name, RAISE_INSPECT(val));
 }
 
 static void lwes_struct_class(
@@ -253,6 +248,19 @@ static void lwes_struct_class(
 	*have_enc = rb_const_get(*event_class, id_HAVE_ENCODING);
 }
 
+#if !defined(RSTRUCT_PTR) && defined(RSTRUCT)
+#  define RSTRUCT_PTR(s) (RSTRUCT(s)->ptr)
+#endif
+static VALUE * rstruct_ptr(VALUE *ary, VALUE rstruct)
+{
+#ifdef RSTRUCT_PTR
+	return RSTRUCT_PTR(*ary = rstruct);
+#else
+	*ary = rb_funcall(rstruct, rb_intern("to_a"), 0, 0);
+	return RARRAY_PTR(*ary);
+#endif
+}
+
 static VALUE emit_struct(VALUE self, VALUE event)
 {
 	VALUE event_class, name, type_list, have_enc;
@@ -264,11 +272,13 @@ static VALUE emit_struct(VALUE self, VALUE event)
 	LWES_U_INT_16 num_attr = 0;
 	size_t num_attr_off;
 	VALUE *flds;
+	char *str;
 
 	lwes_struct_class(&event_class, &name, &type_list, &have_enc, event);
 
 	/* event name */
-	dump_name(name, buf, &off);
+	str = StringValueCStr(name);
+	dump_name(str, buf, &off);
 
 	/* number of attributes, use a placeholder until we've iterated */
 	num_attr_off = off;
@@ -286,12 +296,12 @@ static VALUE emit_struct(VALUE self, VALUE event)
 	}
 
 	i = RARRAY_LEN(type_list);
-	flds = RSTRUCT_PTR(event);
+	flds = rstruct_ptr(&name, event);
 	tmp = RARRAY_PTR(type_list);
 	for (; --i >= 0; tmp++, flds++) {
 		/* inner: [ :field_sym, "field_name", type ] */
 		VALUE *inner = RARRAY_PTR(*tmp);
-		VALUE val, name;
+		VALUE val;
 		LWES_TYPE type;
 
 		if (inner[0] == sym_enc) /* encoding was already dumped */
@@ -301,10 +311,10 @@ static VALUE emit_struct(VALUE self, VALUE event)
 		if (NIL_P(val))
 			continue; /* LWES doesn't know nil */
 
-		name = inner[1];
+		str = StringValueCStr(inner[1]);
 		type = NUM2INT(inner[2]);
 		++num_attr;
-		marshal_field(name, type, val, buf, &off);
+		marshal_field(str, type, val, buf, &off);
 	}
 
 	/* now we've iterated, we can accurately give num_attr */
@@ -476,7 +486,7 @@ static VALUE _create(VALUE self, VALUE options)
 	address = rb_hash_aref(options, ID2SYM(rb_intern("address")));
 	if (TYPE(address) != T_STRING)
 		rb_raise(rb_eTypeError, ":address must be a string");
-	rle->address = my_strdup(RSTRING_PTR(address));
+	rle->address = my_strdup(StringValueCStr(address));
 
 	iface = rb_hash_aref(options, ID2SYM(rb_intern("iface")));
 	switch (TYPE(iface)) {
@@ -484,7 +494,7 @@ static VALUE _create(VALUE self, VALUE options)
 		rle->iface = NULL;
 		break;
 	case T_STRING:
-		rle->iface = my_strdup(RSTRING_PTR(iface));
+		rle->iface = my_strdup(StringValueCStr(iface));
 		break;
 	default:
 		rb_raise(rb_eTypeError, ":iface must be a String or nil");

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

@@ -1,8 +1,11 @@
 #include "lwes_ruby.h"
 VALUE cLWES_Event;
 
+static VALUE tmp_class_name;
+static VALUE SYM2ATTR, CLASSES;
 static ID id_TYPE_DB, id_NAME;
 static VALUE sym_name;
+static VALUE lwesrb_attr_to_value(struct lwes_event_attribute *attr);
 
 struct lwes_event * lwesrb_get_event(VALUE self)
 {
@@ -20,7 +23,6 @@ static void event_free(void *ptr)
 	lwes_event_destroy(event);
 }
 
-
 static VALUE event_alloc(VALUE klass)
 {
 	struct lwes_event *e;
@@ -35,7 +37,7 @@ static VALUE event_alloc(VALUE klass)
 		VALUE type_db = rb_const_get(klass, id_TYPE_DB);
 		struct lwes_event_type_db *tdb = lwesrb_get_type_db(type_db);
 		VALUE name = rb_const_get(klass, id_NAME);
-		const char *ename = StringValuePtr(name);
+		const char *ename = StringValueCStr(name);
 
 		e = lwes_event_create(tdb, ename);
 		if (e == NULL) {
@@ -49,56 +51,85 @@ static VALUE event_alloc(VALUE klass)
 	return Data_Wrap_Struct(klass, NULL, event_free, e);
 }
 
-/*
- * kv - Array:
- *   key => String,
- *   key => [ numeric_type, Numeric ],
- *   key => true,
- *   key => false,
- * memo - lwes_event pointer
- */
-static VALUE event_hash_iter_i(VALUE kv, VALUE memo)
-{
-	/* TODO */
-}
-
 static struct lwes_event_type_db * get_type_db(VALUE self)
 {
 	VALUE type_db = rb_const_get(CLASS_OF(self), id_TYPE_DB);
-	struct lwes_event_type_db *tdb = lwesrb_get_type_db(type_db);
 
-	return tdb;
+	return lwesrb_get_type_db(type_db);
 }
 
-static VALUE event_init(int argc, VALUE *argv, VALUE self)
+static LWES_BYTE get_attr_type(VALUE self, char *attr)
 {
-	VALUE hash;
-	struct lwes_event *event;
+	struct lwes_event_type_db *tdb = get_type_db(self);
+	struct lwes_event *e = lwesrb_get_event(self);
+	struct lwes_hash *ehash = lwes_hash_get(tdb->events, e->eventName);
+	LWES_BYTE *attr_type;
 
-	rb_scan_args(argc, argv, "01", &hash);
+	if (ehash == NULL)
+		rb_raise(rb_eArgError, "invalid event: %s", e->eventName);
 
-	Data_Get_Struct(self, struct lwes_event, event);
+	attr_type = lwes_hash_get(ehash, attr);
+	if (attr_type)
+		return *attr_type;
 
-	return self;
+	ehash = lwes_hash_get(tdb->events, LWES_META_INFO_STRING);
+	if (ehash == NULL)
+		rb_raise(rb_eArgError, "%s not found", LWES_META_INFO_STRING);
+
+	attr_type = lwes_hash_get(ehash, attr);
+	if (attr_type)
+		return *attr_type;
+
+	rb_raise(rb_eArgError, "invalid attribute: %s", attr);
 }
 
-static VALUE event_aset(VALUE self, VALUE key, VALUE val)
+static char *key2attr(VALUE key)
 {
-	struct lwes_event_type_db *tdb = get_type_db(self);
+	if (TYPE(key) == T_SYMBOL)
+		key = rb_hash_aref(SYM2ATTR, key);
+	return StringValueCStr(key);
+}
+
+static VALUE event_aref(VALUE self, VALUE key)
+{
+	char *attr = key2attr(key);
 	struct lwes_event *e = lwesrb_get_event(self);
-	const char *attr = StringValuePtr(key);
-	struct lwes_hash *ehash = lwes_hash_get(tdb->events, e->eventName);
-	LWES_BYTE *attr_type;
+	struct lwes_event_attribute *eattr;
 
-	if (ehash == NULL)
-		rb_raise(rb_eArgError, "invalid event: %s\n", e->eventName);
+	eattr = lwes_hash_get(e->attributes, attr);
+	return eattr ? lwesrb_attr_to_value(eattr) : Qnil;
+}
 
-	attr_type = lwes_hash_get(ehash, attr);
-	if (attr_type == NULL)
-		rb_raise(rb_eArgError, "invalid attribute: %s\n", attr);
+static VALUE event_aset(VALUE self, VALUE key, VALUE val)
+{
+	char *attr = key2attr(key);
+	LWES_BYTE attr_type = get_attr_type(self, attr);
+	struct lwes_event *e = lwesrb_get_event(self);
 
-	switch (*attr_type) {
+	if (attr_type == LWES_STRING_TOKEN) {
+		lwes_event_set_STRING(e, attr, StringValueCStr(val));
+	} else if (attr_type == LWES_U_INT_16_TOKEN) {
+		lwes_event_set_U_INT_16(e, attr, lwesrb_uint16(val));
+	} else if (attr_type == LWES_INT_16_TOKEN) {
+		lwes_event_set_INT_16(e, attr, lwesrb_int16(val));
+	} else if (attr_type == LWES_U_INT_32_TOKEN) {
+		lwes_event_set_U_INT_32(e, attr, lwesrb_uint32(val));
+	} else if (attr_type == LWES_INT_32_TOKEN) {
+		lwes_event_set_INT_32(e, attr, lwesrb_int32(val));
+	} else if (attr_type == LWES_U_INT_64_TOKEN) {
+		lwes_event_set_U_INT_64(e, attr, lwesrb_uint64(val));
+	} else if (attr_type == LWES_INT_64_TOKEN) {
+		lwes_event_set_INT_64(e, attr, lwesrb_int64(val));
+	} else if (attr_type == LWES_IP_ADDR_TOKEN) {
+		lwes_event_set_IP_ADDR(e, attr, lwesrb_ip_addr(val));
+	} else if (attr_type == LWES_BOOLEAN_TOKEN) {
+		lwes_event_set_BOOLEAN(e, attr, lwesrb_boolean(val));
+	} else {
+		rb_raise(rb_eRuntimeError,
+			 "unknown LWES attribute type: 0x%02x",
+			 (unsigned)attr_type);
 	}
+	return val;
 }
 
 static VALUE lwesrb_attr_to_value(struct lwes_event_attribute *attr)
@@ -132,6 +163,8 @@ static VALUE lwesrb_attr_to_value(struct lwes_event_attribute *attr)
 		rb_str_set_len(str, strlen(name));
 		return str;
 	} else {
+		rb_warn("possible event corruption: attr->type=%02x",
+		        (unsigned)attr->type);
 		/*
 		 * possible event corruption
 		 * skip it like the C library does ...
@@ -146,8 +179,49 @@ static VALUE lwesrb_attr_to_value(struct lwes_event_attribute *attr)
 static VALUE to_hash(VALUE self)
 {
 	struct lwes_event *e = lwesrb_get_event(self);
+	VALUE rv = rb_hash_new();
+	VALUE val;
+	struct lwes_hash_enumeration hen;
+	LWES_SHORT_STRING name;
+	VALUE sym_attr_name;
+	struct lwes_event_attribute *attr;
 
-	return lwesrb_event_to_hash(e);
+	if (e->eventName != NULL && CLASS_OF(self) == cLWES_Event) {
+		val = rb_str_new2(e->eventName);
+		rb_hash_aset(rv, sym_name, val);
+	}
+
+	if (! lwes_hash_keys(e->attributes, &hen))
+		return rv;
+	while (lwes_hash_enumeration_has_more_elements(&hen)) {
+		name = lwes_hash_enumeration_next_element(&hen);
+		sym_attr_name = ID2SYM(rb_intern(name));
+		attr = lwes_hash_get(e->attributes, name);
+		if (attr == NULL)
+			rb_raise(rb_eRuntimeError,
+			         "missing attr during enumeration: %s", name);
+		val = lwesrb_attr_to_value(attr);
+		if (! NIL_P(val))
+			rb_hash_aset(rv, sym_attr_name, val);
+	}
+
+	return rv;
+}
+
+VALUE lwesrb_wrap_event(VALUE klass, struct lwes_event *e)
+{
+	if (e->eventName) {
+		long len = strlen(e->eventName);
+		VALUE tmp;
+
+		rb_str_resize(tmp_class_name, len);
+		memcpy(RSTRING_PTR(tmp_class_name), e->eventName, len);
+		tmp = rb_hash_aref(CLASSES, tmp_class_name);
+		if (tmp != Qnil)
+			klass = tmp;
+	}
+
+	return Data_Wrap_Struct(klass, NULL, event_free, e);
 }
 
 /*
@@ -163,8 +237,7 @@ static VALUE to_hash(VALUE self)
  */
 static VALUE parse(VALUE self, VALUE buf)
 {
-	VALUE event = event_alloc(cLWES_Event);
-	struct lwes_event *e = lwesrb_get_event(event);
+	struct lwes_event *e;
 	struct lwes_event_deserialize_tmp dtmp;
 	LWES_BYTE_P bytes;
 	size_t num_bytes;
@@ -173,39 +246,15 @@ static VALUE parse(VALUE self, VALUE buf)
 	StringValue(buf);
 	bytes = (LWES_BYTE_P)RSTRING_PTR(buf);
 	num_bytes = (size_t)RSTRING_LEN(buf);
+	e = lwes_event_create_no_name(NULL);
 	rc = lwes_event_from_bytes(e, bytes, num_bytes, 0, &dtmp);
-	if (rc < 0)
+	if (rc < 0) {
+		lwes_event_destroy(e);
 		rb_raise(rb_eRuntimeError,
-		         "failed to parse LWES event (code: %d)\n", rc);
-	return event;
-}
-
-VALUE lwesrb_event_to_hash(struct lwes_event *e)
-{
-	VALUE rv = rb_hash_new();
-	VALUE val;
-	struct lwes_hash_enumeration hen;
-	LWES_SHORT_STRING name;
-	VALUE sym_attr_name;
-	struct lwes_event_attribute *attr;
-
-	if (e->eventName != NULL) {
-		val = rb_str_new2(e->eventName);
-		rb_hash_aset(rv, sym_name, val);
+		         "failed to parse LWES event (code: %d)", rc);
 	}
 
-	if (! lwes_hash_keys(e->attributes, &hen))
-		return rv;
-	while (lwes_hash_enumeration_has_more_elements(&hen)) {
-		name = lwes_hash_enumeration_next_element(&hen);
-		sym_attr_name = ID2SYM(rb_intern(name));
-		attr = lwes_hash_get(e->attributes, name);
-		val = lwesrb_attr_to_value(attr);
-		if (! NIL_P(val))
-			rb_hash_aset(rv, sym_attr_name, val);
-	}
-
-	return rv;
+	return lwesrb_wrap_event(self, e);
 }
 
 void lwesrb_init_event(void)
@@ -213,10 +262,15 @@ void lwesrb_init_event(void)
 	VALUE mLWES = rb_define_module("LWES");
 	cLWES_Event = rb_define_class_under(mLWES, "Event", rb_cObject);
 
-	rb_define_method(cLWES_Event, "initialize", event_init, -1);
+	SYM2ATTR = rb_const_get(cLWES_Event, rb_intern("SYM2ATTR"));
+	CLASSES = rb_const_get(cLWES_Event, rb_intern("CLASSES"));
 	rb_define_alloc_func(cLWES_Event, event_alloc);
 	rb_define_singleton_method(cLWES_Event, "parse", parse, 1);
 	rb_define_method(cLWES_Event, "to_hash", to_hash, 0);
+	rb_define_method(cLWES_Event, "[]", event_aref, 1);
+	rb_define_method(cLWES_Event, "[]=", event_aset, 2);
+	tmp_class_name = rb_str_new(0, 0);
+	rb_global_variable(&tmp_class_name);
 
 	LWESRB_MKID(TYPE_DB);
 	LWESRB_MKID(NAME);