cosmos 4.0.0-universal-java-1.8

data/ext/cosmos/ext/low_fragmentation_array/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O3')
+  $CFLAGS << ' -O3'
+end
+if CONFIG['CC'] =~ /gcc/
+  $CFLAGS << ' -Wall'
+  if $DEBUG && !$CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
+    $CFLAGS << ' -O0 -ggdb'
+  end
+end
+
+create_makefile 'cosmos/ext/low_fragmentation_array'

data/ext/cosmos/ext/low_fragmentation_array/low_fragmentation_array.c

@@ -0,0 +1,265 @@
+/*
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+*/
+
+#include "ruby.h"
+#include "stdio.h"
+#include <assert.h>
+
+VALUE mCosmos;
+
+/* Reference to LowFragmentationArray class */
+VALUE cLowFragmentationArray = Qnil;
+
+#define ARY_DEFAULT_SIZE 16
+#define ARY_MAX_SIZE (LONG_MAX / (int)sizeof(VALUE))
+#define FL_SET_EMBED(a) do { \
+    assert(!ARY_SHARED_P(a)); \
+    assert(!OBJ_FROZEN(a)); \
+    FL_SET(a, RARRAY_EMBED_FLAG); \
+} while (0)
+#define FL_UNSET_EMBED(ary) FL_UNSET(ary, RARRAY_EMBED_FLAG|RARRAY_EMBED_LEN_MASK)
+#define RARRAY_SHARED_ROOT_FLAG FL_USER5
+#define ARY_SHARED_ROOT_P(ary) (FL_TEST(ary, RARRAY_SHARED_ROOT_FLAG))
+#define ARY_SHARED_P(ary) \
+    (assert(!FL_TEST(ary, ELTS_SHARED) || !FL_TEST(ary, RARRAY_EMBED_FLAG)), \
+     FL_TEST(ary,ELTS_SHARED)!=0)
+#define ARY_EMBED_P(ary) \
+    (assert(!FL_TEST(ary, ELTS_SHARED) || !FL_TEST(ary, RARRAY_EMBED_FLAG)), \
+     FL_TEST(ary, RARRAY_EMBED_FLAG)!=0)
+#define ARY_SET_PTR(ary, p) do { \
+    assert(!ARY_EMBED_P(ary)); \
+    assert(!OBJ_FROZEN(ary)); \
+    RARRAY(ary)->as.heap.ptr = (p); \
+} while (0)
+#define ARY_SET_EMBED_LEN(ary, n) do { \
+    long tmp_n = n; \
+    assert(ARY_EMBED_P(ary)); \
+    assert(!OBJ_FROZEN(ary)); \
+    RBASIC(ary)->flags &= ~RARRAY_EMBED_LEN_MASK; \
+    RBASIC(ary)->flags |= (tmp_n) << RARRAY_EMBED_LEN_SHIFT; \
+} while (0)
+#define ARY_SET_HEAP_LEN(ary, n) do { \
+    assert(!ARY_EMBED_P(ary)); \
+    RARRAY(ary)->as.heap.len = n; \
+} while (0)
+#define ARY_SET_LEN(ary, n) do { \
+    if (ARY_EMBED_P(ary)) { \
+        ARY_SET_EMBED_LEN(ary, n); \
+    } \
+    else { \
+        ARY_SET_HEAP_LEN(ary, n); \
+    } \
+    assert(RARRAY_LEN(ary) == n); \
+} while (0)
+#define ARY_CAPA(ary) (ARY_EMBED_P(ary) ? RARRAY_EMBED_LEN_MAX : \
+		       ARY_SHARED_ROOT_P(ary) ? RARRAY_LEN(ary) : RARRAY(ary)->as.heap.aux.capa)
+#define ARY_SET_CAPA(ary, n) do { \
+    assert(!ARY_EMBED_P(ary)); \
+    assert(!ARY_SHARED_P(ary)); \
+    assert(!OBJ_FROZEN(ary)); \
+    RARRAY(ary)->as.heap.aux.capa = (n); \
+} while (0)
+
+/*
+ * Allocates memory for a new array
+ * Note: Implementation almost exactly the same
+ * as Ruby 1.9.2 p0 (have to copy because static)
+ */
+static VALUE my_ary_alloc (VALUE klass)
+{
+  NEWOBJ(ary, struct RArray);
+  OBJSETUP((VALUE)ary, klass, T_ARRAY);
+  FL_SET_EMBED((VALUE)ary);
+  ARY_SET_EMBED_LEN((VALUE)ary, 0);
+
+  return (VALUE)ary;
+}
+
+/*
+ * Creates a new array of the original class type
+ * Note: Implementation almost exactly the same as
+ * Ruby 1.9.2 p0
+ */
+static VALUE my_ary_new (VALUE klass, long capa)
+{
+  volatile VALUE ary;
+
+  if (capa < 0)
+  {
+    rb_raise(rb_eArgError, "negative array size (or size too big)");
+  }
+  if (capa > ARY_MAX_SIZE)
+  {
+    rb_raise(rb_eArgError, "array size too big");
+  }
+  ary = my_ary_alloc(klass);
+  if (capa > RARRAY_EMBED_LEN_MAX)
+  {
+    FL_UNSET_EMBED(ary);
+    ARY_SET_PTR(ary, ALLOC_N(VALUE, capa));
+    ARY_SET_CAPA(ary, capa);
+    ARY_SET_HEAP_LEN(ary, 0);
+  }
+
+  return ary;
+}
+
+/*
+ * Allocates space for an array but leaves the array length at 0
+ */
+static VALUE initialize (VALUE self, VALUE size)
+{
+  rb_call_super(1, &size);
+  ARY_SET_LEN(self, 0);
+  return self;
+}
+
+/*
+ * Extract array range
+ */
+static VALUE my_ary_subseq (VALUE ary, long beg, long len)
+{
+  volatile VALUE klass = Qnil;
+  volatile VALUE ary2  = Qnil;
+
+  if (beg > RARRAY_LEN(ary))
+  {
+    return Qnil;
+  }
+  if (beg < 0 || len < 0)
+  {
+    return Qnil;
+  }
+
+  if (RARRAY_LEN(ary) < len || RARRAY_LEN(ary) < beg + len)
+  {
+    len = RARRAY_LEN(ary) - beg;
+  }
+  klass = rb_obj_class(ary);
+  if (len == 0)
+  {
+    return my_ary_new(klass, 0);
+  }
+
+  ary2 = my_ary_new(klass, len);
+  MEMCPY(RARRAY_PTR(ary2), RARRAY_PTR(ary) + beg, VALUE, len);
+  ARY_SET_LEN(ary2, len);
+
+  return ary2;
+}
+
+/*
+ * Array reference - creates new memory for range rather than shared object
+ * Note: Almost exactly the same as the implementation from
+ * Ruby 1.9.2 p0
+ */
+static VALUE ary_aref(int argc, VALUE *argv, VALUE ary)
+{
+  volatile VALUE arg;
+  long beg, len;
+
+  if (argc == 2)
+  {
+    beg = NUM2LONG(argv[0]);
+    len = NUM2LONG(argv[1]);
+    if (beg < 0)
+    {
+      beg += RARRAY_LEN(ary);
+    }
+    return my_ary_subseq(ary, beg, len);
+  }
+  if (argc != 1)
+  {
+    rb_scan_args(argc, argv, "11", 0, 0);
+  }
+  arg = argv[0];
+  /* special case - speeding up */
+  if (FIXNUM_P(arg))
+  {
+    return rb_ary_entry(ary, FIX2LONG(arg));
+  }
+  /* check if idx is Range */
+  switch (rb_range_beg_len(arg, &beg, &len, RARRAY_LEN(ary), 0))
+  {
+    case Qfalse:
+      break;
+    case Qnil:
+      return Qnil;
+    default:
+      return my_ary_subseq(ary, beg, len);
+  }
+  return rb_ary_entry(ary, NUM2LONG(arg));
+}
+
+/*
+ * Removes values before an index and shifts old values down
+ * without fragmenting memory by reallocating memory.
+ */
+static VALUE remove_before_bang (VALUE self, VALUE index)
+{
+  int int_index = FIX2INT(index);
+  long new_length = 0;
+
+  if (int_index < 0)
+  {
+    int_index += RARRAY_LEN(self);
+    if (int_index < 0)
+    {
+      return self;
+    }
+  }
+
+  if (RARRAY_LEN(self) > int_index)
+  {
+    MEMMOVE(RARRAY_PTR(self), RARRAY_PTR(self) + int_index, VALUE, RARRAY_LEN(self) - int_index);
+    new_length = RARRAY_LEN(self) - int_index;
+    ARY_SET_LEN(self, new_length);
+  }
+  else
+  {
+    ARY_SET_LEN(self, 0);
+  }
+
+  return self;
+}
+
+/*
+ * Returns the size of memory allocated for the array
+ */
+static VALUE capacity (VALUE self)
+{
+  return LONG2NUM(ARY_CAPA(self));
+}
+
+/*
+ * Returns the array's pointer
+ */
+static VALUE pointer (VALUE self)
+{
+#if __x86_64__
+  return LL2NUM((long long) RARRAY_PTR(self));
+#else
+  return LONG2NUM((long) RARRAY_PTR(self));
+#endif
+}
+
+/*
+ * Initialize methods for C LowFragmentationArray
+ */
+void Init_low_fragmentation_array (void)
+{
+  mCosmos = rb_define_module("Cosmos");
+  cLowFragmentationArray = rb_define_class_under(mCosmos, "LowFragmentationArray", rb_cArray);
+  rb_define_method(cLowFragmentationArray, "initialize", initialize, 1);
+  rb_define_method(cLowFragmentationArray, "[]", ary_aref, -1);
+  rb_define_method(cLowFragmentationArray, "remove_before!", remove_before_bang, 1);
+  rb_define_method(cLowFragmentationArray, "capacity", capacity, 0);
+  rb_define_method(cLowFragmentationArray, "pointer", pointer, 0);
+}

data/ext/cosmos/ext/packet/extconf.rb

@@ -0,0 +1,13 @@
+require 'mkmf'
+
+unless $CFLAGS.gsub!(/ -O[\dsz]?/, ' -O3')
+  $CFLAGS << ' -O3'
+end
+if CONFIG['CC'] =~ /gcc/
+  $CFLAGS << ' -Wall'
+  if $DEBUG && !$CFLAGS.gsub!(/ -O[\dsz]?/, ' -O0 -ggdb')
+    $CFLAGS << ' -O0 -ggdb'
+  end
+end
+
+create_makefile 'cosmos/ext/packet'

data/ext/cosmos/ext/packet/packet.c

@@ -0,0 +1,350 @@
+/*
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+*/
+
+#include "ruby.h"
+#include "stdio.h"
+
+#include "../structure/structure.c"
+
+static VALUE cPacket = Qnil;
+static VALUE cPacketItem = Qnil;
+
+static ID id_method_class = 0;
+static ID id_method_target_name_equals = 0;
+static ID id_method_packet_name_equals = 0;
+static ID id_method_description_equals = 0;
+static ID id_method_upcase = 0;
+static ID id_method_clone = 0;
+static ID id_method_clear = 0;
+
+static ID id_ivar_id_items = 0;
+static ID id_ivar_id_value = 0;
+static ID id_ivar_received_time = 0;
+static ID id_ivar_received_count = 0;
+static ID id_ivar_hazardous = 0;
+static ID id_ivar_hazardous_description = 0;
+static ID id_ivar_given_values = 0;
+static ID id_ivar_limits_items = 0;
+static ID id_ivar_processors = 0;
+static ID id_ivar_stale = 0;
+static ID id_ivar_limits_change_callback = 0;
+static ID id_ivar_read_conversion_cache = 0;
+static ID id_ivar_raw = 0;
+static ID id_ivar_messages_disabled = 0;
+static ID id_ivar_meta = 0;
+static ID id_ivar_hidden = 0;
+static ID id_ivar_disabled = 0;
+static ID id_ivar_target_name = 0;
+static ID id_ivar_packet_name = 0;
+static ID id_ivar_description = 0;
+
+/* Wraps read_item_internal so that it can be called by rb_protect in protected_read_item_internal */
+static VALUE wrap_read_item_internal(VALUE args)
+{
+  volatile VALUE *values = (VALUE *)args;
+  volatile VALUE self = values[0];
+  volatile VALUE item = values[1];
+  volatile VALUE buffer = values[2];
+  return read_item_internal(self, item, buffer);
+}
+
+/* Wraps read_item_internal to catch any exceptions and return nil on exception */
+static VALUE protected_read_item_internal(VALUE self, VALUE item, VALUE buffer)
+{
+  int error = 0;
+  volatile VALUE result = Qnil;
+  volatile VALUE args[3];
+
+  args[0] = self;
+  args[1] = item;
+  args[2] = buffer;
+  result = rb_protect(wrap_read_item_internal, (VALUE)args, &error);
+
+  if (error) {
+    return Qnil;
+  } else {
+    return result;
+  }
+}
+
+/*
+ * Tries to identify if a buffer represents the currently defined packet. It
+ * does this by iterating over all the packet items that were created with
+ * an ID value and checking whether that ID value is present at the correct
+ * location in the buffer.
+ *
+ * Incorrectly sized buffers will still positively identify if there is
+ * enough data to match the ID values. This is to allow incorrectly sized
+ * packets to still be processed as well as possible given the incorrectly
+ * sized data.
+ *
+ * @param buffer [String] Raw buffer of binary data
+ * @return [Boolean] Whether or not the buffer of data is this packet
+ */
+static VALUE identify(VALUE self, VALUE buffer)
+{
+  volatile VALUE id_items = rb_ivar_get(self, id_ivar_id_items);
+  volatile VALUE item = Qnil;
+  volatile VALUE id_value = Qnil;
+  volatile VALUE raw_value = Qnil;
+  long id_items_length = 0;
+  int index = 0;
+
+  if (!RTEST(buffer)) {
+    return Qfalse;
+  }
+
+  if (!RTEST(id_items)) {
+    return Qtrue;
+  }
+
+  id_items_length = RARRAY_LEN(id_items);
+
+  for (index = 0; index < id_items_length; index++) {
+    item = rb_ary_entry(id_items, index);
+    id_value = rb_ivar_get(item, id_ivar_id_value);
+    raw_value = protected_read_item_internal(self, item, buffer);
+    if (!rb_eql(id_value, raw_value)) {
+      return Qfalse;
+    }
+  }
+
+  return Qtrue;
+}
+
+/* Sets the target name this packet is associated with. Unidentified packets
+ * will have target name set to nil.
+ *
+ * @param target_name [String] Name of the target this packet is associated with */
+static VALUE target_name_equals(VALUE self, VALUE target_name) {
+  if (RTEST(target_name)) {
+    if (rb_funcall(target_name, id_method_class, 0) != rb_cString) {
+      rb_raise(rb_eArgError, "target_name must be a String but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(target_name, id_method_class, 0), id_method_to_s, 0)));
+    }
+    rb_ivar_set(self, id_ivar_target_name, rb_funcall(rb_funcall(target_name, id_method_upcase, 0), id_method_freeze, 0));
+  } else {
+    rb_ivar_set(self, id_ivar_target_name, Qnil);
+  }
+  return rb_ivar_get(self, id_ivar_target_name);
+}
+
+/* Sets the packet name. Unidentified packets will have packet name set to
+ * nil.
+ *
+ * @param packet_name [String] Name of the packet */
+static VALUE packet_name_equals(VALUE self, VALUE packet_name) {
+  if (RTEST(packet_name)) {
+    if (rb_funcall(packet_name, id_method_class, 0) != rb_cString) {
+      rb_raise(rb_eArgError, "packet_name must be a String but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(packet_name, id_method_class, 0), id_method_to_s, 0)));
+    }
+    rb_ivar_set(self, id_ivar_packet_name, rb_funcall(rb_funcall(packet_name, id_method_upcase, 0), id_method_freeze, 0));
+  } else {
+    rb_ivar_set(self, id_ivar_packet_name, Qnil);
+  }
+  return rb_ivar_get(self, id_ivar_packet_name);
+}
+
+/* Sets the description of the packet
+ *
+ * @param description [String] Description of the packet */
+static VALUE description_equals(VALUE self, VALUE description) {
+  if (RTEST(description)) {
+    if (rb_funcall(description, id_method_class, 0) != rb_cString) {
+      rb_raise(rb_eArgError, "description must be a String but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(description, id_method_class, 0), id_method_to_s, 0)));
+    }
+    rb_ivar_set(self, id_ivar_description, rb_funcall(rb_funcall(description, id_method_clone, 0), id_method_freeze, 0));
+  } else {
+    rb_ivar_set(self, id_ivar_description, Qnil);
+  }
+  return rb_ivar_get(self, id_ivar_description);
+}
+
+/* Sets the received time of the packet
+ *
+ * @param received_time [Time] Time this packet was received */
+static VALUE received_time_equals(VALUE self, VALUE received_time) {
+  volatile VALUE read_conversion_cache = rb_ivar_get(self, id_ivar_read_conversion_cache);
+  if (RTEST(received_time)) {
+    if (rb_funcall(received_time, id_method_class, 0) != rb_cTime) {
+      rb_raise(rb_eArgError, "received_time must be a Time but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(received_time, id_method_class, 0), id_method_to_s, 0)));
+    }
+    rb_ivar_set(self, id_ivar_received_time, rb_funcall(rb_funcall(received_time, id_method_clone, 0), id_method_freeze, 0));
+  } else {
+    rb_ivar_set(self, id_ivar_received_time, Qnil);
+  }
+  if (RTEST(read_conversion_cache)) {
+    rb_funcall(read_conversion_cache, id_method_clear, 0);
+  }
+  return rb_ivar_get(self, id_ivar_received_time);
+}
+
+/* Sets the received count of the packet
+ *
+ * @param received_count [Integer] Number of times this packet has been
+ *   received */
+static VALUE received_count_equals(VALUE self, VALUE received_count) {
+  volatile VALUE read_conversion_cache = rb_ivar_get(self, id_ivar_read_conversion_cache);
+#ifdef RUBY_INTEGER_UNIFICATION /* Ruby 2.4.0 unified Fixnum and Bignum into Integer. This check allows the code to build pre- and post-2.4.0. */
+  if (rb_funcall(received_count, id_method_class, 0) != rb_cInteger) {
+    rb_raise(rb_eArgError, "received_count must be an Integer but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(received_count, id_method_class, 0), id_method_to_s, 0)));
+  }
+#else
+  if ((rb_funcall(received_count, id_method_class, 0) != rb_cFixnum) && (rb_funcall(received_count, id_method_class, 0) != rb_cBignum)) {
+    rb_raise(rb_eArgError, "received_count must be an Integer but is a %s", RSTRING_PTR(rb_funcall(rb_funcall(received_count, id_method_class, 0), id_method_to_s, 0)));
+  }
+#endif
+  rb_ivar_set(self, id_ivar_received_count, received_count);
+  if (RTEST(read_conversion_cache)) {
+    rb_funcall(read_conversion_cache, id_method_clear, 0);
+  }
+  return rb_ivar_get(self, id_ivar_received_count);
+}
+
+/* Creates a new packet by initalizing the attributes.
+ *
+ * @param target_name [String] Name of the target this packet is associated with
+ * @param packet_name [String] Name of the packet
+ * @param default_endianness [Symbol] One of {BinaryAccessor::ENDIANNESS}
+ * @param description [String] Description of the packet
+ * @param buffer [String] String buffer to hold the packet data
+ * @param item_class [Class] Class used to instantiate items (Must be a
+ *   subclass of PacketItem)
+ */
+static VALUE packet_initialize(int argc, VALUE* argv, VALUE self) {
+  volatile VALUE target_name = Qnil;
+  volatile VALUE packet_name = Qnil;
+  volatile VALUE default_endianness = Qnil;
+  volatile VALUE description = Qnil;
+  volatile VALUE buffer = Qnil;
+  volatile VALUE item_class = Qnil;
+  volatile VALUE super_args[3] = {Qnil, Qnil, Qnil};
+
+  switch (argc)
+  {
+    case 2:
+      target_name = argv[0];
+      packet_name = argv[1];
+      default_endianness = symbol_BIG_ENDIAN;
+      description = Qnil;
+      buffer = rb_str_new2("");
+      item_class = cPacketItem;
+      break;
+    case 3:
+      target_name = argv[0];
+      packet_name = argv[1];
+      default_endianness = argv[2];
+      description = Qnil;
+      buffer = rb_str_new2("");
+      item_class = cPacketItem;
+      break;
+    case 4:
+      target_name = argv[0];
+      packet_name = argv[1];
+      default_endianness = argv[2];
+      description = argv[3];
+      buffer = rb_str_new2("");
+      item_class = cPacketItem;
+      break;
+    case 5:
+      target_name = argv[0];
+      packet_name = argv[1];
+      default_endianness = argv[2];
+      description = argv[3];
+      buffer = argv[4];
+      item_class = cPacketItem;
+      break;
+    case 6:
+      target_name = argv[0];
+      packet_name = argv[1];
+      default_endianness = argv[2];
+      description = argv[3];
+      buffer = argv[4];
+      item_class = argv[5];
+      break;
+    default:
+      /* Invalid number of arguments given */
+      rb_raise(rb_eArgError, "wrong number of arguments (%d for 2..6)", argc);
+      break;
+  };
+
+  super_args[0] = default_endianness;
+  super_args[1] = buffer;
+  super_args[2] = item_class;
+  rb_call_super(3, (VALUE*) super_args);
+  target_name_equals(self, target_name);
+  packet_name_equals(self, packet_name);
+  description_equals(self, description);
+  rb_ivar_set(self, id_ivar_received_time, Qnil);
+  rb_ivar_set(self, id_ivar_received_count, INT2FIX(0));
+  rb_ivar_set(self, id_ivar_id_items, Qnil);
+  rb_ivar_set(self, id_ivar_hazardous, Qfalse);
+  rb_ivar_set(self, id_ivar_hazardous_description, Qnil);
+  rb_ivar_set(self, id_ivar_given_values, Qnil);
+  rb_ivar_set(self, id_ivar_limits_items, Qnil);
+  rb_ivar_set(self, id_ivar_processors, Qnil);
+  rb_ivar_set(self, id_ivar_stale, Qtrue);
+  rb_ivar_set(self, id_ivar_limits_change_callback, Qnil);
+  rb_ivar_set(self, id_ivar_read_conversion_cache, Qnil);
+  rb_ivar_set(self, id_ivar_raw, Qnil);
+  rb_ivar_set(self, id_ivar_messages_disabled, Qfalse);
+  rb_ivar_set(self, id_ivar_meta, Qnil);
+  rb_ivar_set(self, id_ivar_hidden, Qfalse);
+  rb_ivar_set(self, id_ivar_disabled, Qfalse);
+
+  return self;
+}
+
+/*
+ * Initialize all Packet methods
+ */
+void Init_packet (void)
+{
+  Init_structure();
+
+  id_method_class = rb_intern("class");
+  id_method_target_name_equals = rb_intern("target_name=");
+  id_method_packet_name_equals = rb_intern("packet_name=");
+  id_method_description_equals = rb_intern("description=");
+  id_method_upcase = rb_intern("upcase");
+  id_method_clone = rb_intern("clone");
+  id_method_clear = rb_intern("clear");
+
+  id_ivar_id_items = rb_intern("@id_items");
+  id_ivar_id_value = rb_intern("@id_value");
+  id_ivar_received_time = rb_intern("@received_time");
+  id_ivar_received_count = rb_intern("@received_count");
+  id_ivar_hazardous = rb_intern("@hazardous");
+  id_ivar_hazardous_description = rb_intern("@hazardous_description");
+  id_ivar_given_values = rb_intern("@given_values");
+  id_ivar_limits_items = rb_intern("@limits_items");
+  id_ivar_processors = rb_intern("@processors");
+  id_ivar_stale = rb_intern("@stale");
+  id_ivar_limits_change_callback = rb_intern("@limits_change_callback");
+  id_ivar_read_conversion_cache = rb_intern("@read_conversion_cache");
+  id_ivar_raw = rb_intern("@raw");
+  id_ivar_messages_disabled = rb_intern("@messages_disabled");
+  id_ivar_meta = rb_intern("@meta");
+  id_ivar_hidden = rb_intern("@hidden");
+  id_ivar_disabled = rb_intern("@disabled");
+  id_ivar_target_name = rb_intern("@target_name");
+  id_ivar_packet_name = rb_intern("@packet_name");
+  id_ivar_description = rb_intern("@description");
+
+  cPacket = rb_define_class_under(mCosmos, "Packet", cStructure);
+  rb_define_method(cPacket, "initialize", packet_initialize, -1);
+  rb_define_method(cPacket, "identify?", identify, 1);
+  rb_define_method(cPacket, "packet_name=", packet_name_equals, 1);
+  rb_define_method(cPacket, "target_name=", target_name_equals, 1);
+  rb_define_method(cPacket, "description=", description_equals, 1);
+  rb_define_method(cPacket, "received_time=", received_time_equals, 1);
+  rb_define_method(cPacket, "received_count=", received_count_equals, 1);
+
+  cPacketItem = rb_define_class_under(mCosmos, "PacketItem", cStructureItem);
+}