cauterize 0.0.1.pre12 → 0.0.1.pre13

data/spec/support/spec_sample_model.rb

@@ -17,7 +17,6 @@ module Cauterize
       end
 
       Cauterize.variable_array(:int8_list) do |a|
-        a.size_type  :uint8
         a.array_type :int8
         a.array_size 200
       end
@@ -53,9 +52,8 @@ module Cauterize
       end
 
       Cauterize.variable_array(:int8_list) do |a|
-        a.size_type  :uint8
         a.array_type :int8
-        a.array_size 200
+        a.array_size 2000
       end
 
       Cauterize.composite(:two_things) do |t|

data/spec/variable_array_spec.rb

@@ -61,26 +61,12 @@ module Cauterize
     end
 
     describe :size_type do
-      it "defines the type to use to encode the array size" do
-        Cauterize.scalar(:uint16_t)
-        @a.size_type :uint16_t
-        @a.instance_variable_get(:@size_type).name.should == :uint16_t
-      end
-
-      it "raises an error if the type doesn't eixst" do
-        lambda { @a.size_type :uintLOL_t }.should raise_error /does not correspond to a type/
-      end
+      it "determines the type used to encode the array size" do
+        @a.array_size 30000
+        @a.size_type.name.should == :uint16
 
-      it "raises an error if the type isn't an scalar" do
-        Cauterize.scalar(:uint32_t) { |t| t.type_name(:uint32) }
-        Cauterize.enumeration(:lol)
-        lambda { @a.size_type :lol }.should raise_error /is not a built-in or scalar/
-      end
-
-      it "is the defined type if no argument is passed" do
-        s = Cauterize.scalar(:uint32_t)
-        @a.size_type :uint32_t
-        @a.size_type.should be s
+        @a.array_size 10
+        @a.size_type.name.should == :uint8
       end
     end
   end

data/support/cs/src/CauterizeFixedArrayFormatter.cs

@@ -11,16 +11,27 @@ namespace Cauterize
         }
         public override object Deserialize(Stream serializationStream, Type t)
         {
-            var ret = t.GetConstructor(new Type[] {}).Invoke(new object[] {});
             var arrayField = t.BaseType.GetField("_data", BindingFlags.NonPublic | BindingFlags.Instance);
-            var array = (Array)arrayField.GetValue(ret);
             var arrayType = arrayField.FieldType.GetElementType();
-            var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
-            for (var i = 0; i < array.Length; i++)
+            if (arrayType == typeof (Byte))
             {
-                array.SetValue(subFormatter.Deserialize(serializationStream, arrayType), i);
+                var arraySize = (int) t.GetField("MySize").GetValue(null);
+                var arrayData = new byte[arraySize];
+                serializationStream.Read(arrayData, 0, arraySize);
+                var ret = t.GetConstructor(new Type[] {typeof (Byte[])}).Invoke(new object[] {arrayData});
+                return ret;
+            }
+            else
+            {
+                var ret = t.GetConstructor(new Type[] {}).Invoke(new object[] {});
+                var array = (Array)arrayField.GetValue(ret);
+                var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
+                for (var i = 0; i < array.Length; i++)
+                {
+                    array.SetValue(subFormatter.Deserialize(serializationStream, arrayType), i);
+                }
+                return ret;
             }
-            return ret;
         }
 
         public override void Serialize(Stream serializationStream, object obj)
@@ -29,10 +40,17 @@ namespace Cauterize
             var arrayField = t.BaseType.GetField("_data", BindingFlags.NonPublic | BindingFlags.Instance);
             var array = (Array)arrayField.GetValue(obj);
             var arrayType = arrayField.FieldType.GetElementType();
-            var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
-            for (var i = 0; i < array.Length; i++)
+            if (arrayType == typeof (Byte))
+            {
+                serializationStream.Write((byte[]) array, 0, array.Length);
+            }
+            else
             {
-                subFormatter.Serialize(serializationStream, array.GetValue(i));
+                var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
+                for (var i = 0; i < array.Length; i++)
+                {
+                    subFormatter.Serialize(serializationStream, array.GetValue(i));
+                }
             }
         }
     }

data/support/cs/src/CauterizeVariableArrayFormatter.cs

@@ -14,20 +14,30 @@ namespace Cauterize
 
         public override object Deserialize(Stream serializationStream, Type t)
         {
+            var arrayField = t.BaseType.GetField("_data", BindingFlags.NonPublic | BindingFlags.Instance);
+            var arrayType = arrayField.FieldType.GetElementType();
             var sizeType = (Type) t.GetField("SizeType").GetValue(null);
             var sizeFormatter = _typeFormatterFactory.GetFormatter(sizeType);
             var rawSize = sizeFormatter.Deserialize(serializationStream, sizeType);
             var arraySize = PrimitiveSupport.TypeToInt(rawSize);
-            var ret = t.GetConstructor(new Type[] {typeof (int)}).Invoke(new object[] {arraySize});
-            var arrayField = t.BaseType.GetField("_data", BindingFlags.NonPublic | BindingFlags.Instance);
-            var array = (Array)arrayField.GetValue(ret);
-            var arrayType = arrayField.FieldType.GetElementType();
-            var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
-            for (var i = 0; i < arraySize; i++)
+            if (arrayType == typeof (Byte))
             {
-                array.SetValue(subFormatter.Deserialize(serializationStream, arrayType), i);
+                var arrayData = new byte[arraySize];
+                serializationStream.Read(arrayData, 0, arraySize);
+                var ret = t.GetConstructor(new Type[] {typeof (Byte[])}).Invoke(new object[] {arrayData});
+                return ret;
+            }
+            else
+            {
+                var ret = t.GetConstructor(new Type[] {typeof (int)}).Invoke(new object[] {arraySize});
+                var array = (Array)arrayField.GetValue(ret);
+                var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
+                for (var i = 0; i < arraySize; i++)
+                {
+                    array.SetValue(subFormatter.Deserialize(serializationStream, arrayType), i);
+                }
+                return ret;
             }
-            return ret;
         }
 
         public override void Serialize(Stream serializationStream, object obj)
@@ -39,10 +49,17 @@ namespace Cauterize
             var sizeFormatter = _typeFormatterFactory.GetFormatter(sizeType);
             sizeFormatter.Serialize(serializationStream, PrimitiveSupport.IntToType(sizeType, array.Length));
             var arrayType = arrayField.FieldType.GetElementType();
-            var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
-            for (var i = 0; i < array.Length; i++)
+            if (arrayType == typeof (Byte))
+            {
+                serializationStream.Write((byte[])array, 0, array.Length);
+            }
+            else
             {
-                subFormatter.Serialize(serializationStream, array.GetValue(i));
+                var subFormatter = _typeFormatterFactory.GetFormatter(arrayType);
+                for (var i = 0; i < array.Length; i++)
+                {
+                    subFormatter.Serialize(serializationStream, array.GetValue(i));
+                }
             }
         }
     }

data/support/ruby/src/cauterize_ruby_baseclasses.rb

@@ -1,246 +1,367 @@
 require 'stringio'
 
-class CauterizeData
-  def self.construct(x)
-    if x.is_a? CauterizeData
-      raise "Invalid Type: was #{x.class}, expected #{self.name}" if not x.is_a?(self)
+module CauterizeRuby
+  class Data
+    @@specializers = Hash.new { |h, k| k }
+
+    def self.set_specializer(c)
+      @@specializers[self] = c
+    end
+
+    def self.do_construct(x)
+      if x.is_a? Data
+        raise "Invalid Type: was #{x.class}, expected #{self}" if not x.is_a?(self)
+        x
+      else
+        self.new x
+      end
+    end
+
+    def self.construct(x)
+      @@specializers[self].do_construct(x)
+    end
+
+    def self.unpackio(x)
+      @@specializers[self].do_unpackio(x)
+    end
+
+    def pack
+      x = ""
+      packio(x)
       x
-    else
-      self.new x
     end
-  end
 
-  def self.unpack(x)
-    self.unpackio(StringIO.new(x))
-  end
-end
+    def self.unpack(x)
+      self.unpackio(StringIO.new(x))
+    end
 
-class CauterizeBuiltin < CauterizeData
-  def initialize(val)
-    raise "Out of range value" if not in_range(val)
-    @val = val
-  end
-  def to_ruby
-    @val
-  end
-end
+    def ==(other)
+      (self <=> other) == 0
+    end
 
-class CauterizeBuiltinInteger < CauterizeBuiltin
-  def initialize(val)
-    super(val.to_i)
+    #this promotes 'other' to a cauterize type if it's not one already
+    #   this way 'cmp' can always assume 'other' is of the same type
+    def <=>(other)
+      cmp(self.class.construct(other))
+    end
   end
 
-  def to_i
-    @val
+  class Builtin < Data
+    def initialize(val)
+      @val = val
+    end
+    def to_ruby
+      @val
+    end
+    # for builtins max_size == min_size
+    def self.min_size() max_size end
+    def num_bytes() self.class::max_size end
   end
-end
 
-class CauterizeBuiltinFloat < CauterizeBuiltin
-  def initialize(val)
-    super(val.to_f)
-  end
+  class BuiltinInteger < Builtin
+    def initialize(val)
+      #this will always set @val to a regular ruby Fixnum
+      super(val.to_i)
+    end
 
-  def to_f
-    @val
-  end
-end
+    def to_i
+      @val
+    end
 
-class CauterizeBuiltinBool < CauterizeBuiltin
-  def initialize(val)
-    super((val)? true : false)
+    def to_f
+      @val.to_f
+    end
   end
-end
 
+  class BuiltinFloat < Builtin
+    def initialize(val)
+      #this will always set @val to a regular ruby float
+      super(val.to_f)
+    end
 
-class CauterizeScalar < CauterizeData
-  def initialize(val)
-    @val = self.class.builtin.construct val
-  end
+    def to_f
+      @val
+    end
 
-  def to_ruby
-    @val.to_ruby
+    def to_i
+      @val.to_i
+    end
   end
 
-  def pack
-    @val.pack
+  class BuiltinBool < Builtin
+    def initialize(val)
+      #this will always set @val to a regular ruby boolean value
+      super((val)? true : false)
+    end
   end
 
-  def self.unpackio(str)
-    self.new self.builtin.unpackio(str)
-  end
-end
 
-class CauterizeArray < CauterizeData
-  def to_ruby
-    @elems.map{|e| e.to_ruby}
-  end
+  class Scalar < Data
+    attr_reader :builtin
+    def initialize(val)
+      # @builtin is going to be some form of Builtin
+      @builtin = self.class.builtin.construct val
+      raise "#{self.class}: Out of range value: #{@builtin.to_ruby}, for #{self.class}" if not @builtin.in_range(@builtin.to_ruby)
+    end
 
-  def to_string
-    to_ruby.to_a.pack("C*")
-  end
-end
+    def to_ruby
+      @builtin.to_ruby
+    end
 
-class CauterizeFixedArray < CauterizeArray
-  attr_reader :elems
+    def to_i
+      @builtin.to_i
+    end
 
-  def initialize(elems)
-    @elems = elems.map { |e| self.class.elem_type.construct(e) }
-    raise "Invalid length" if @elems.length != self.class.length
-  end
+    def to_f
+      @builtin.to_f
+    end
 
-  def pack
-    @elems.inject("") { |sum, n| sum + n.pack }
-  end
+    def packio(x)
+      @builtin.packio(x)
+    end
+
+    def self.do_unpackio(str)
+      self.new self.builtin.unpackio(str)
+    end
 
-  def self.unpackio(str)
-    self.new (1..self.length).map { self.elem_type.unpackio(str) }
+    def cmp(other)
+      @builtin <=> other.builtin
+    end
+
+    def num_bytes() @builtin.num_bytes end
+    def self.max_size() builtin::max_size end
+    def self.min_size() builtin::min_size end
   end
-end
 
+  class Array < Data
 
-class CauterizeVariableArray < CauterizeArray
-  attr_reader :length
-  attr_reader :elems
+    include Enumerable
 
-  def initialize(elems)
-    @elems = elems.map { |e| self.class.elem_type.construct(e) }
-    @length = self.class.size_type.new @elems.length
-    raise "Invalid length" if @elems.length > self.class.max_length
-  end
+    def initialize(elems)
+      if elems.is_a? String
+        # a special case for strings
+        initialize_arr(elems.unpack("C*"))
+      else
+        initialize_arr(elems)
+      end
+    end
 
-  def pack
-    @length.pack + @elems.inject("") { |sum, n| sum + n.pack }
-  end
+    def each
+      elems.each do |e|
+        yield e
+      end
+    end
 
-  def self.unpackio(str)
-    length = self.size_type.unpackio(str)
-    self.new (1..length.to_i).map { self.elem_type.unpackio(str) }
+    def to_ruby
+      @elems.map{|e| e.to_ruby}
+    end
+
+    def to_string
+      to_ruby.to_a.pack("C*")
+    end
+
+    def cmp(other)
+      elems <=> other.elems
+    end
   end
-end
 
+  class FixedArray < Array
+    attr_reader :elems
 
-class CauterizeComposite < CauterizeData
-  attr_reader :fields
+    def initialize_arr(elems)
+      @elems = elems.map { |e| self.class.elem_type.construct(e) }
+      raise "#{self.class}: Invalid length: #{@elems.length}, expected: #{self.class.length}" if @elems.length != self.class.length
+    end
 
-  def initialize(field_values)
-    missing_keys = self.class.fields.keys - field_values.keys
-    extra_keys = field_values.keys - self.class.fields.keys
-    raise "missing fields #{missing_keys}" if not missing_keys.empty?
-    raise "extra fields #{extra_keys}" if not extra_keys.empty?
-    @fields = Hash[field_values.map do |field_name, value|
-      [field_name, self.class.fields[field_name].construct(value)]
-    end]
-  end
+    def packio(x)
+      elems.each do |e|
+        e.packio(x)
+      end
+    end
 
-  def to_ruby
-    Hash[@fields.map{|name, value| [name, value.to_ruby]}]
-  end
+    def self.do_unpackio(str)
+      self.new (1..self.length).map { self.elem_type.unpackio(str) }
+    end
 
-  def pack
-    @fields.values.inject("")  { |sum, v| sum + v.pack }
+    def num_bytes() elems.reduce(0) {|sum, e| sum + e.num_bytes} end
+    def self.max_size() length * elem_type::max_size end
+    def self.min_size() length * elem_type::min_size end
   end
 
-  def self.unpackio(str)
-    self.new Hash[self.fields.keys.map do |k|
-      [k, self.fields[k].unpackio(str)]
-    end]
-  end
 
-  alias orig_method_missing method_missing
+  class VariableArray < Array
+    attr_reader :length
+    attr_reader :elems
+
+    def initialize_arr(elems)
+      @elems = elems.map { |e| self.class.elem_type.construct(e) }
+      @length = self.class.size_type.new @elems.length
+      raise "#{self.class}: Invalid length: #{@elems.length}, max length is: #{self.class.max_length}" if @elems.length > self.class.max_length
+    end
 
-  def method_missing(m, *args, &block)
-    if fields[m]
-      fields[m]
-    else
-      orig_method_missing(m, *args, &block)
+    def packio(x)
+      @length.packio(x)
+      @elems.each do |e|
+        e.packio(x)
+      end
     end
+   
+    def self.do_unpackio(str)
+      length = self.size_type.unpackio(str)
+      self.new (1..length.to_i).map { self.elem_type.unpackio(str) }
+    end
+
+    def num_bytes() length.num_bytes + elems.reduce(0) {|sum, e| sum + e.num_bytes} end
+    def self.max_size() size_type::max_size + (max_length * elem_type::max_size) end
+    def self.min_size() size_type::min_size end
   end
-end
 
 
-class CauterizeEnumeration < CauterizeData
-  attr_reader :field_name
+  class Composite < Data
+    attr_reader :fields
 
-  def initialize(field_name)
-    raise "Invalid field name #{field_name}" if not self.class.fields.keys.include?(field_name)
-    @field_name = field_name
-  end
+    def initialize(field_values)
+      missing_keys = self.class.fields.keys - field_values.keys
+      extra_keys = field_values.keys - self.class.fields.keys
+      bad_init = !extra_keys.empty? || !missing_keys.empty?
+      raise "#{self.class}: Invalid initialization params, missing fields: #{missing_keys}, extra fields: #{extra_keys}" if bad_init
+      @fields = Hash[self.class.fields.keys.map do |field_name|
+        [field_name, self.class.fields[field_name].construct(field_values[field_name])]
+      end]
+    end
 
-  def to_ruby
-    @field_name
-  end
+    def to_ruby
+      Hash[@fields.map{|name, value| [name, value.to_ruby]}]
+    end
 
-  def to_i() self.class.fields[@field_name] end
+    def packio(x)
+      @fields.values.each do |v|
+        v.packio(x)
+      end
+    end
 
-  def pack
-    self.class.repr_type.construct(self.class.fields[@field_name]).pack
-  end
+    def self.do_unpackio(str)
+      self.new Hash[self.fields.keys.map do |k|
+        [k, self.fields[k].unpackio(str)]
+      end]
+    end
 
-  def self.from_int(i)
-    raise "Invalid enumeration value #{i.to_i}" if not self.fields.values.include? i.to_i
-    self.new(self.fields.invert[i.to_i])
-  end
+    def cmp(other)
+      fields.values <=> other.fields.values
+    end
+
+    def num_bytes
+      fields.values.reduce(0) {|sum, v| sum + v.num_bytes}
+    end
 
-  def self.unpackio(str)
-    self.from_int(self.repr_type.unpackio(str).to_i)
+    def self.max_size
+      fields.values.reduce(0) {|sum, v| sum + v::max_size}
+    end
+
+    def self.min_size
+      fields.values.reduce(0) {|sum, v| sum + v::min_size}
+    end
   end
-end
 
 
-class CauterizeGroup < CauterizeData
-  attr_reader :tag
-  attr_reader :data
+  class Enumeration < Data
+    attr_reader :field_name
 
-  def to_ruby
-    if data.nil?
-      { tag: tag_field_name }
-    else
-      { tag: tag_field_name,
-        data: data.to_ruby }
+    def initialize(field_name)
+      raise "#{self.class}: Invalid field name: #{field_name}, Valid field names are: #{self.class.fields.keys}" if not self.class.fields.keys.include?(field_name)
+      @field_name = field_name
     end
-  end
 
-  def tag_field_name
-    self.class.from_tag_field_name(@tag.field_name)
-  end
+    def to_ruby
+      @field_name
+    end
 
-  def self.tag_from_field_name(field_name)
-    self.tag_type.construct((self.tag_prefix + field_name.to_s).to_sym)
-  end
+    def to_i() self.class.fields[@field_name] end
 
-  def self.from_tag_field_name(tag_name)
-    t = tag_name.to_s
-    t.slice!(self.tag_prefix)
-    t.to_sym
-  end
-  
-  def initialize(h)
-    @tag = self.class.tag_from_field_name(h[:tag])
+    def packio(x)
+      self.class.repr_type.construct(self.class.fields[@field_name]).packio(x)
+    end
 
-    field_class = self.class.fields[tag_field_name]
-    if field_class.nil?
-      @data = nil
-    else
-      @data = field_class.construct(h[:data])
+    def self.from_int(i)
+      raise "#{self}: Invalid enumeration value: #{i.to_i}" if not self.fields.values.include? i.to_i
+      self.new(self.fields.invert[i.to_i])
+    end
+
+    def self.do_unpackio(str)
+      self.from_int(self.repr_type.unpackio(str).to_i)
     end
-  end
 
-  def pack
-    if @data.nil?
-      @tag.pack
-    else
-      @tag.pack + @data.pack
+    def cmp(other)
+      to_i <=> other.to_i
     end
+
+    def num_bytes() self.class.repr_type::max_size end
+    def self.max_size() repr_type::max_size end
+    def self.min_size() repr_type::min_size end
   end
 
-  def self.unpackio(str)
-    tag = self.tag_type.unpackio(str)
-    field_name = self.from_tag_field_name(tag.field_name)
-    data_type = self.fields[field_name]
-    if data_type.nil?
-      self.new({ tag: field_name })
-    else
-      self.new({ tag: field_name, data: data_type.unpackio(str) })
+
+  class Group < Data
+    attr_reader :tag
+    attr_reader :data
+
+    def to_ruby
+      if data.nil?
+        { tag: tag_field_name }
+      else
+        { tag: tag_field_name,
+          data: data.to_ruby }
+      end
+    end
+
+    def tag_field_name
+      self.class.from_tag_field_name(@tag.field_name)
+    end
+
+    def self.tag_from_field_name(field_name)
+      self.tag_type.construct((self.tag_prefix + field_name.to_s).to_sym)
+    end
+
+    def self.from_tag_field_name(tag_name)
+      t = tag_name.to_s
+      t.slice!(self.tag_prefix)
+      t.to_sym
+    end
+    
+    def initialize(h)
+      @tag = self.class.tag_from_field_name(h[:tag])
+      field_class = self.class.fields[tag_field_name]
+      @data = (field_class.nil?) ? nil : field_class.construct(h[:data])
+    end
+
+    def packio(x)
+      @tag.packio(x)
+      @data.packio(x) unless @data.nil?
+    end
+
+    def self.do_unpackio(str)
+      tag = self.tag_type.unpackio(str)
+      field_name = self.from_tag_field_name(tag.field_name)
+      data_type = self.fields[field_name]
+      if data_type.nil?
+        self.new({ tag: field_name })
+      else
+        self.new({ tag: field_name, data: data_type.unpackio(str) })
+      end
     end
+
+    def cmp(other)
+      r = (tag <=> other.tag)
+      if r == 0
+        data <=> other.data
+      else
+        r
+      end
+    end
+
+    def num_bytes() tag.num_bytes + ((data.nil?) ? 0 : data.num_bytes) end
+
+    def self.max_size() tag_type::max_size + fields.values.map{|v| (v.nil?) ? 0 : v::max_size}.max end
+    def self.min_size() tag_type::min_size + fields.values.map{|v| (v.nil?) ? 0 : v::min_size}.min end
   end
 end