ffi-struct_ex 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d550f7884cc459c4dbf3f506f6952fc9dc2f345
-  data.tar.gz: 7087461425de5d646a04f5e8bc75749d908cbb7b
+  metadata.gz: 640a03806e45782319f75058970cf5c999927d03
+  data.tar.gz: f5f3247405c6243e66a4d958d356787cb231c7d8
 SHA512:
-  metadata.gz: 1db936827a6652292e2849fd93ea54ad7f14c5f2c53503c9be3f1cbebec24287541197e66d1162cc30ea0969fb31b8e2a3f996d39bbd34b28ba3f732fd0c8720
-  data.tar.gz: 4e85fe3b694f1ac30ea118e450f7c0e63df8f295c32fd33f9bb6cff1ddca0a850a8bbb3cd379e9828f5c0bb9c782808a232115f7915ab303140e25bcccb98ab1
+  metadata.gz: 57dcf4abe3d98e2fe8c0cbcbaed6e17e2ac2a8d877f1c57d53da3f97666099e73de65cca320714451e535ab0a5724361d6c3bbc965838d50d7a58209a4779867
+  data.tar.gz: ece4cba95fbf5095e5151432f072957ed6d3d8eaf4b6e56ace473d745dfa48ccd12c4531464a6cb185698012b1cb942769181e2bcb92649f83023c76378ef8b0

data/README.md

@@ -63,7 +63,10 @@ subject[:field_0].read #=> 0b0110_1101
 subject[:field_0] = {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}
 subject[:field_0].read #=> 0b0110_1001
 
+#Equality check
 subject[:field_0] == {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011} #=> true
+subject[:field_0] == 0b0110_1001 #=> true
+subject[:field_0] == '0b0110_1001' #=> true
 ```
 
 ## Contributing

data/lib/ffi/struct_ex/struct_ex.rb

@@ -11,19 +11,29 @@ class Integer
   end
 end
 
+class String
+  def to_dec
+    case self
+      when /^[+-]?\d+$/
+        self.to_i
+      when /^[+-]?0[xX][\da-fA-F_]+$/
+        self.to_i(16)
+      when /^[+-]?0[bB][_01]+$/
+        self.to_i(2)
+    end
+  end
+end
+
 module FFI
   class StructEx < FFI::Struct
-    BitLayout = ::Struct.new(:name, :bits, :offset, :texts)
-
     class << self
-      def bit_fields(*descs)
+      def bit_fields(*field_specs)
         struct_class = Class.new(StructEx) do
-          layout(*descs)
+          layout(*field_specs)
         end
 
         bit_fields_class = Class.new(FFI::StructLayout::Field) do
           def initialize(name, offset, type)
-            #TODO use a different native_type to avoid dummy field for struct
             super(name, offset, FFI::Type::Struct.new(self.class.struct_class))
           end
 
@@ -42,51 +52,63 @@ module FFI
             def alignment
               struct_class.alignment
             end
+
+            def size
+              struct_class.size
+            end
           end
 
           self.struct_class = struct_class
         end
       end
 
-      attr_reader :bits_size, :bit_layouts
+      attr_reader :bits_size, :field_specs, :has_bit_field
 
-      def layout(*descs)
-        if descs.size == 0 || !descs[1].is_a?(Integer)
-          super(*descs)
-          #@bits_size = self.size * 8
-        else
-          @bit_layouts = {}
+      def layout(*field_specs)
+        return super if field_specs.size == 0
+
+        field_spec_class = ::Struct.new(:name, :type, :bits_offset, :descriptors)
+
+        @field_specs = {}
+
+        i = bits_offset = 0
 
-          index = @bits_size = 0
+        while i < field_specs.size
+          field_name, type = field_specs[i, 2]
+          i += 2
 
-          while index < descs.size
-            bit_field_name, bits, texts = descs[index, 3]
+          unless type.is_a?(Integer)
+            type = find_field_type(type)
+            bits_size = type.size * 8
 
-            if texts.kind_of?(Hash)
-              @bit_layouts[bit_field_name] = BitLayout.new(bit_field_name, bits, @bits_size, texts)
-              index += 3
-            else
-              @bit_layouts[bit_field_name] = BitLayout.new(bit_field_name, bits, @bits_size)
-              index += 2
+            if field_specs[i].is_a?(Integer)
+              bits_offset = field_specs[i] * 8
+              i += 1
             end
+          else
+            bits_size = type
+          end
 
-            @bits_size += bits
+          if field_specs[i].is_a?(Hash)
+            descriptors = field_specs[i]
+            i += 1
+          else
+            descriptors = {}
           end
 
-          #FIXME consider 24 bits situation or larger than 32 bits
-          #FIXME remove dummy field or have a better name for this field
-          super(:dummy, "uint#{bytes_size * 8}".to_sym)
+          @field_specs[field_name] = field_spec_class.new(field_name, type, bits_offset, descriptors)
+          bits_offset += bits_size
         end
-      end
 
-      def bytes_size
-        (bits_size + 7) >> 3
-      end
+        @has_bit_field = @field_specs.any? {|field_name, field_spec| field_spec.type.is_a?(Integer)}
 
-      def alignment
-        return super unless self.bit_layouts
-        #FIXME consider 24 bits situation
-        FFI.find_type("uint#{bytes_size * 8}".to_sym).alignment
+        if @has_bit_field
+          #FIXME consider 24 bits situation or larger than 32 bits
+          #FIXME remove dummy field or have a better name for this field
+          super(:dummy, "uint#{(bits_offset + 7) & (-1 << 3)}".to_sym)
+        else
+          super(*field_specs.reject {|field_spec| field_spec.is_a?(Hash)})
+        end
       end
     end
 
@@ -99,77 +121,73 @@ module FFI
       end
     end
 
-    def [](bit_field_name)
-      return super unless self.class.bit_layouts && self.class.bit_layouts.keys.include?(bit_field_name)
+    def [](field_name)
+      return super unless self.class.has_bit_field
 
-      bit_layout = self.class.bit_layouts[bit_field_name]
-      mask = ((1 << bit_layout.bits) - 1) << bit_layout.offset
+      field_spec = self.class.field_specs[field_name]
+      mask = ((1 << field_spec.type) - 1) << field_spec.bits_offset
 
-      (self.read & mask) >> bit_layout.offset
+      (self.read & mask) >> field_spec.bits_offset
     end
 
-    def []=(bit_field_name, value)
-      return super unless self.class.bit_layouts && self.class.bit_layouts.keys.include?(bit_field_name)
+    # Set field value
+    def []=(field_name, value)
+      value = map_field_value(field_name, value)
 
-      value = look_for_value(bit_field_name, value)
+      return super(field_name, value) unless self.class.has_bit_field
 
-      bit_layout = self.class.bit_layouts[bit_field_name]
-      mask = ((1 << bit_layout.bits) - 1) << bit_layout.offset
+      field_spec = self.class.field_specs[field_name]
+      mask = ((1 << field_spec.type) - 1) << field_spec.bits_offset
 
-      self.write((self.read & (-1 - mask)) | ((value << bit_layout.offset) & mask))
+      self.write((self.read & (-1 - mask)) | ((value << field_spec.bits_offset) & mask))
     end
 
     def write(value)
       if value.is_a?(Integer)
-        to_ptr.write_array_of_uint8(value.to_bytes(self.class.bytes_size))
+        to_ptr.write_array_of_uint8(value.to_bytes(self.class.size))
       elsif value.is_a?(Hash)
-        value.each do |bit_field_name, v|
-          self[bit_field_name] = v if self.class.bit_layouts.keys.include? bit_field_name
+        value.each do |field_name, v|
+          self[field_name] = v
         end
       end
     end
 
     def read
-      bytes = to_ptr.read_array_of_uint8(self.class.bytes_size)
+      bytes = to_ptr.read_array_of_uint8(self.class.size)
       bytes.reverse.inject(0) {|value, n| (value << 8) | n}
     end
 
-    def size
-      self.class.bytes_size
-    end
-
     def ==(other)
       if other.is_a?(Integer)
         self.read == other
+      elsif other.is_a?(String)
+        self.==(other.to_dec)
       elsif other.is_a?(Hash)
-        other.all? {|k, v| self[k] == self.look_for_value(k, v)}
+        other.all? {|k, v| self[k] == self.map_field_value(k, v)}
       else
         super
       end
     end
 
-    def look_for_value(bit_field_name, value)
-      #FIXME add error handling
-      if value.kind_of?(Integer)
-        value
-      elsif value.kind_of?(String)
-        #FIXME this requires texts hash to have downcase key
-        value = value.downcase
-        if self.class.bit_layouts[bit_field_name].texts && self.class.bit_layouts[bit_field_name].texts[value]
-          self.class.bit_layouts[bit_field_name].texts[value]
-        else
-          case value
-            when /^\d+$/
-              value.to_i
-            when /^0x[\da-fA-F]+$/
-              value.to_i(16)
-            when /^0b[01]+$/
-              value.to_i(2)
-          end
-        end
-      else
-        value
-      end
+    # Return mapped field value by converting {value} to corresponding native form.
+    # The priority is
+    #   1. look for descriptors
+    #   2. simple conversion from string to integer if integer type
+    #   3. {value} itself
+    #
+    # @param [String, Symbol] field_name name of the field
+    # @param [String, Integer, Object] value value in descriptive form or native form
+    # @return [Object] value in native form
+    def map_field_value(field_name, value)
+      field_spec = self.class.field_specs[field_name]
+
+      descriptor_key = value.kind_of?(String) ? value.downcase : value
+      return field_spec.descriptors[descriptor_key] if field_spec.descriptors.has_key?(descriptor_key)
+
+      type = field_spec.type
+      return value.to_dec if (type.is_a?(Integer) || FFI::StructLayoutBuilder::NUMBER_TYPES.include?(type)) && value.is_a?(String)
+
+      value
     end
   end
 end

data/lib/ffi/struct_ex/version.rb

@@ -1,5 +1,5 @@
 module Ffi
   module StructEx
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/test/test_struct_ex.rb

@@ -36,12 +36,16 @@ class TestStructEx < Test::Unit::TestCase
     assert_equal(0b0110_1001, subject[:field_0].read)
     assert_equal(0b001, subject[:field_0][:bits_0_2])
 
-    assert(subject[:field_0] == {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011})
+    assert(subject[:field_0] == {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011, bits_8_15: 0b0})
+    assert(subject[:field_0] == 0b0110_1001)
+    assert(subject[:field_0] == '0b0110_1001')
 
     subject[:field_1] = 1
     subject[:field_2] = 2
     subject[:field_3] = 3
-    assert(subject == {field_0: {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}, field_1: 1, field_2: 2, field_3: 3})
+    assert(subject == {field_0: {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011, bits_8_15: 0b0}, field_1: 1, field_2: 2, field_3: 3})
+    assert(subject == 0x0302010069)
+    assert(subject == '0x0302010069')
   end
 
   def test_pure_bit_fields
@@ -104,4 +108,70 @@ class TestStructEx < Test::Unit::TestCase
     subject[:bit_3] = 1
     assert_equal(0b1, subject[:bit_3])
   end
+
+  def test_equality
+    subject_class = Class.new(FFI::StructEx) do
+      layout :field_0, bit_fields(:bits_0_2, 3,
+                                  :bit_3,    1,
+                                  :bit_4,    1,
+                                  :bits_5_7, 3),
+             :field_1, :uint8
+    end
+
+    subject = subject_class.new({field_0: {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}, field_1: 0x1})
+
+    assert_equal(FFI::StructEx, subject[:field_0].class.superclass)
+    assert_equal(1, subject[:field_0].size)
+    assert(subject[:field_0] == 0b0110_1001)
+    assert(subject[:field_1] == subject.map_field_value(:field_1, '0x1'))
+  end
+
+  def test_descriptors
+    subject_class = Class.new(FFI::StructEx) do
+      layout :field_0, :uint8, {'all_1' => 0xff, 'all_0' => 0x00},
+             :field_1, :uint8, {3 => 1}
+    end
+
+    assert_equal(2, subject_class.size)
+    assert_equal(1, subject_class.alignment)
+    assert_equal(1, subject_class.offset_of(:field_1))
+
+    subject = subject_class.new(field_0: 'all_1', field_1: 0x12)
+
+    assert_equal(0xff, subject[:field_0])
+    assert_equal(0x12, subject[:field_1])
+
+    subject[:field_0] = 'all_0'
+    assert_equal(0x00, subject[:field_0])
+
+    subject[:field_0] = 0x12
+    assert_equal(0x12, subject[:field_0])
+
+    subject[:field_1] = 3
+    assert_equal(0x1, subject[:field_1])
+  end
+
+  def test_initialized_memory_should_be_zero
+    subject_class = Class.new(FFI::StructEx) do
+      layout :field_0, bit_fields(:bits_0_2, 3,
+                                  :bit_3,    1,
+                                  :bit_4,    1,
+                                  :bits_5_7, 3),
+             :field_1, :uint8
+    end
+
+    subject = subject_class.new
+
+    assert_equal(0x00, subject[:field_0])
+    assert_equal(0x00, subject[:field_1])
+  end
+
+  # def test_sizeof
+    # subject_class = Class.new(FFI::StructEx) do
+      # layout :field_0, 2,
+             # :field_1, 31
+    # end
+#
+    # assert_equal(8, subject_class.size)
+  # end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-struct_ex
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Ruijia Li
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-19 00:00:00.000000000 Z
+date: 2014-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi