ffi-struct_ex 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f351f025099f8a13f3c2aeba992b7fd67d8dd90b
-  data.tar.gz: 198834f90618214c7ffb3a811d3de12c114dd4db
+  metadata.gz: 4092e8230ac37c9885fe7fa0103252632d8aff4c
+  data.tar.gz: b7585d0ea88c05cec20c3cac0939fbecf54fd114
 SHA512:
-  metadata.gz: 31828f46959ae2d4a4686b787f0555b3f320c12bfb80d7375920d1a45e8e620a27dc1f75cf13a19233ea157ac208e22f7e1909305cf156ca0b66894e256e22c5
-  data.tar.gz: daf79112bfa648f3aa9343319cf5e21d2cae9668ef1df5a98544e4af347279408032267184325fa080c7bd031446fcc8583327de83bf6b259cbd84d3b3281b39
+  metadata.gz: b90c7ec9a5a6e5d2fdcb84346a19c9882de73a601d9cb35d6e18c05455648f6e700c92a61ea2ca2007659c3fe830b031a3a4408111fd1c7a26e79c8c75c1f1b4
+  data.tar.gz: b2077caf64d8b31265a2b30ec2c72690181ac5cb1f5be710a56888a7f75a546eaa853be20be7cce7c5c8b7fd2e2edc60eda30e6b78c867dd7f436f728fb6d905

data/lib/ffi/struct_ex/struct_ex.rb

@@ -1,15 +1,6 @@
 require 'ffi'
 
 class Integer
-  def to_bytes(size)
-    bytes = [0] * size
-    bytes.each_index do |i|
-      bytes[i] = (self >> (i * 8)) & 0xff
-    end
-
-    bytes
-  end
-
   def to_signed(bits_size)
     self & (1 << bits_size - 1) != 0 ? self - (1 << bits_size) : self
   end
@@ -32,9 +23,10 @@ module FFI
   class StructEx < FFI::Struct
     SIGNED_NUMBER_TYPES = [FFI::Type::INT8, FFI::Type::INT16, FFI::Type::INT32, FFI::Type::INT64]
     UNSIGNED_NUMBER_TYPES = [FFI::Type::UINT8, FFI::Type::UINT16, FFI::Type::UINT32, FFI::Type::UINT64]
+    NUMBER_TYPES = SIGNED_NUMBER_TYPES + UNSIGNED_NUMBER_TYPES
 
     class << self
-      def bit_fields(*field_specs)
+      def struct_ex(*field_specs)
         Class.new(FFI::StructLayout::Field) do
           class << self
             attr_accessor :struct_class
@@ -104,13 +96,13 @@ module FFI
 
       private
       def array_layout(builder, field_specs)
-        @field_specs = {}
-
         field_spec_class = ::Struct.new(:name, :type, :descriptors)
 
-        current_allocation_unit = nil
+        @field_specs = {}
+
+        bits_unit = nil
 
-        offset = i = 0
+        i = 0
 
         while i < field_specs.size
           name, type = field_specs[i, 2]
@@ -128,7 +120,7 @@ module FFI
             type = find_field_type(type)
             builder.add name, type, offset
 
-            current_allocation_unit = nil
+            bits_unit = nil
           else
             if type.is_a?(Integer)
               ffi_type, bits_size = UNSIGNED_NUMBER_TYPES.find {|ffi_type| type <= ffi_type.size * 8}, type
@@ -138,32 +130,22 @@ module FFI
               raise "Unrecognized format #{type}" unless m
 
               ffi_type, bits_size = find_field_type(m[:ffi_type].to_sym), m[:bits_size].to_i
-              raise "Unrecognized type #{type}" unless UNSIGNED_NUMBER_TYPES.include?(ffi_type) || SIGNED_NUMBER_TYPES.include?(ffi_type)
+              raise "Unrecognized type #{type}" unless NUMBER_TYPES.include?(ffi_type)
             end
 
             raise "Illegal format #{type}" if bits_size > ffi_type.size * 8
 
-            unless current_allocation_unit
-              current_allocation_unit = {ffi_type: ffi_type, bits_size: bits_size}
-              offset = builder.send(:align, builder.size, [@min_alignment || 1, ffi_type.alignment].max)
+            # Adjacent bit fields are packed into the same 1-, 2-, or 4-byte allocation unit if the integral types are the same size
+            # and if the next bit field fits into the current allocation unit without crossing the boundary
+            # imposed by the common alignment requirements of the bit fields.
+            if bits_unit && bits_unit[:ffi_type].size == ffi_type.size && bits_unit[:bits_size] + bits_size <= bits_unit[:ffi_type].size * 8
+              bits_unit[:bits_size] += bits_size
             else
-              # Adjacent bit fields are packed into the same 1-, 2-, or 4-byte allocation unit if the integral types are the same size
-              # and if the next bit field fits into the current allocation unit without crossing the boundary
-              # imposed by the common alignment requirements of the bit fields.
-              if ffi_type.size == current_allocation_unit[:ffi_type].size
-                if current_allocation_unit[:bits_size] + bits_size <= ffi_type.size * 8
-                  current_allocation_unit[:bits_size] += bits_size
-                else
-                  offset = builder.send(:align, builder.size, [@min_alignment || 1, ffi_type.alignment].max)
-                  current_allocation_unit[:bits_size] = bits_size
-                end
-              else
-                offset = builder.send(:align, builder.size, [@min_alignment || 1, ffi_type.alignment].max)
-                current_allocation_unit = {ffi_type: ffi_type, bits_size: bits_size}
-              end
+              offset = builder.send(:align, builder.size, [@min_alignment || 1, ffi_type.alignment].max)
+              bits_unit = {ffi_type: ffi_type, bits_size: bits_size}
             end
 
-            builder.add name, find_field_type(bit_field(ffi_type, bits_size, current_allocation_unit[:bits_size] - bits_size)), offset
+            builder.add name, find_field_type(bit_field(ffi_type, bits_size, bits_unit[:bits_size] - bits_size)), offset
           end
 
           if field_specs[i].is_a?(Hash)
@@ -193,26 +175,17 @@ module FFI
     end
 
     def write(value)
-      if value.is_a?(Integer)
-        to_ptr.write_array_of_uint8(value.to_bytes(self.class.size))
-      elsif value.is_a?(Hash)
+      if value.is_a?(Hash)
         value.each do |field_name, v|
           self[field_name] = v
         end
+      elsif value.is_a?(self.class)
+        self.pointer.__copy_from__(value.pointer, self.size)
       end
     end
 
-    def read
-      bytes = to_ptr.read_array_of_uint8(self.class.size)
-      bytes.reverse.inject(0) {|value, n| (value << 8) | n}
-    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)
+      if other.is_a?(Hash)
         other.all? {|k, v| self[k] == self.map_field_value(k, v)}
       else
         super

data/lib/ffi/struct_ex/version.rb

@@ -1,5 +1,5 @@
 module Ffi
   module StructEx
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/test/test_struct_ex.rb

@@ -3,53 +3,53 @@ require 'test/unit'
 require 'ffi/struct_ex'
 
 class TestStructEx < Test::Unit::TestCase
-  def test_bit_fields
+  def test_struct_ex
     subject_class = Class.new(FFI::StructEx) do
-      layout :field_0, bit_fields(:bits_0_2, 'uint16: 3',
+      layout :field_0, struct_ex(:bits_0_2, 'uint16: 3',
                                   :bit_3,    'uint16: 1',
                                   :bit_4,    'uint16: 1',
                                   :bits_5_7, 'uint16: 3',
-                                  :bits_8_15, 'uint16: 8'),
+                                  :bits_8_15, :uint8),
              :field_1, :uint8,
              :field_2, :uint8,
              :field_3, :uint8
     end
 
-    assert_equal(6, subject_class.size)
+    assert_equal(8, subject_class.size)
     assert_equal(2, subject_class.alignment)
-    assert_equal(2, subject_class.offset_of(:field_1))
+    assert_equal(4, subject_class.offset_of(:field_1))
 
     subject = subject_class.new
 
     assert_equal(FFI::StructEx, subject[:field_0].class.superclass)
-    assert_equal(2, subject[:field_0].size)
+    assert_equal(4, subject[:field_0].size)
     assert_equal(2, subject[:field_0].alignment)
 
-    subject[:field_0] = 0b0110_1001
-    assert_equal(0b0110_1001, subject[:field_0].read)
+    subject[:field_0].to_ptr.write_uint16(0b0110_1001)
+    assert_equal(0b0110_1001, subject[:field_0].to_ptr.read_uint16)
     assert_equal(0b001, subject[:field_0][:bits_0_2])
 
     subject[:field_0][:bits_0_2] = 0b101
     assert_equal(0b101, subject[:field_0][:bits_0_2])
-    assert_equal(0b0110_1101, subject[:field_0].read)
+    assert_equal(0b0110_1101, subject[:field_0].to_ptr.read_uint16)
 
     subject[:field_0] = {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}
-    assert_equal(0b0110_1001, subject[:field_0].read)
+    assert_equal(0b0110_1001, subject[:field_0].to_ptr.read_uint16)
     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, bits_8_15: 0b0})
-    assert(subject[:field_0] == 0b0110_1001)
-    assert(subject[:field_0] == '0b0110_1001')
+    assert_equal(subject[:field_0], {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011, bits_8_15: 0b0})
+    assert_equal(subject[:field_0].to_ptr.read_uint16, 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, bits_8_15: 0b0}, field_1: 1, field_2: 2, field_3: 3})
-    assert(subject == 0x0302010069)
-    assert(subject == '0x0302010069')
+    assert_equal(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})
+
+    subject[:field_0] = subject[:field_0].class.new(bits_0_2: 0b111, bit_3: 0b0, bit_4: 0b0, bits_5_7: 0b101, bits_8_15: 0b10011100)
+    assert_equal(subject[:field_0].to_ptr.read_uint32, 0b10011100_00000000_10100111)
   end
 
-  def test_pure_bit_fields
+  def test_pure_struct_ex
     subject_class = Class.new(FFI::StructEx) do
       layout :bits_0_2, 3,
              :bit_3,    1,
@@ -69,7 +69,8 @@ class TestStructEx < Test::Unit::TestCase
     assert_equal(0b1, subject[:bit_3])
     assert_equal(0b101, subject[:bits_0_2])
 
-    subject = subject_class.new(0b0110_1001)
+    subject = subject_class.new
+    subject.to_ptr.write_uint8(0b0110_1001)
     assert_equal(0b001, subject[:bits_0_2])
     assert_equal(0b1, subject[:bit_3])
     assert_equal(0b0, subject[:bit_4])
@@ -80,10 +81,10 @@ class TestStructEx < Test::Unit::TestCase
     assert_equal(0b1, subject[:bit_3])
     assert_equal(0b0, subject[:bit_4])
     assert_equal(0b011, subject[:bits_5_7])
-    assert_equal(0b0110_1001, subject.read)
+    assert_equal(0b0110_1001, subject.to_ptr.read_uint8)
   end
 
-  def test_interpreted_bit_fields
+  def test_interpreted_struct_ex
     subject_class = Class.new(FFI::StructEx) do
       layout :bits_0_2, 3, {'all_1' => 0b111, 'all_0' => 0b000},
              :bit_3,    1, {'yes' => 0b1, 'no' => 0b0},
@@ -112,18 +113,18 @@ class TestStructEx < Test::Unit::TestCase
 
   def test_equality
     subject_class = Class.new(FFI::StructEx) do
-      layout :field_0, bit_fields(:bits_0_2, 3,
+      layout :field_0, struct_ex(: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})
+    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_equal(0b0110_1001, subject[:field_0])
+    assert_equal(0b0110_1001, subject[:field_0].to_ptr.read_uint8)
     assert_equal(subject[:field_1], subject.map_field_value(:field_1, '0x1'))
   end
 
@@ -154,7 +155,7 @@ class TestStructEx < Test::Unit::TestCase
 
   def test_initialized_memory_should_be_zero
     subject_class = Class.new(FFI::StructEx) do
-      layout :field_0, bit_fields(:bits_0_2, 3,
+      layout :field_0, struct_ex(:bits_0_2, 3,
                                   :bit_3,    1,
                                   :bit_4,    1,
                                   :bits_5_7, 3),
@@ -163,7 +164,7 @@ class TestStructEx < Test::Unit::TestCase
 
     subject = subject_class.new
 
-    assert_equal(0x00, subject[:field_0])
+    assert_equal(0x00, subject[:field_0].to_ptr.read_uint8)
     assert_equal(0x00, subject[:field_1])
   end
 

metadata

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