snow-data 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de5502dc1786af224a1344f0221110e87bae22a0
-  data.tar.gz: 207bffe6bbe3d1bf6f6ff3bef67615b12ef3767d
+  metadata.gz: 40d3b634a2fe9ad1783ff57bd03dbdb9e01d28a4
+  data.tar.gz: 0087c9dd8a0f26fbc239b518d66243ee4b391f48
 SHA512:
-  metadata.gz: c38b07ce23e8fc20c451c5d529d535e9bbe826a5e41f149d5903c29a53ac7d01024d0becda54c7e75e4c24e07f1b216fe4a87a45098394b121eb3de309bd860f
-  data.tar.gz: a71c448abd01932b31ec66d5bb197469b6b6521404fa270f20a45ae150eb51d798011e1fe56daea4d1421d684cf145c333582ecd6aa1d1db523f1bca01a5b5b6
+  metadata.gz: 7e8e6ec2a0160b4ba35170e73d4db301bb99a6af90a769f72ee75e8e1aef4d6ccb0708f4f84546330721ae134487261e8c8ac4dd2897cf9b56f8f229ed257c53
+  data.tar.gz: a46085a0735417717a5af9a952027e1e711b292b0b76406dd2522e038ca21473bcd38e15562503747ae4c3f09430d5a418d7ea286c839bcf00e91af41dd7c6f3

data/README.md

@@ -53,36 +53,35 @@ How you use it, ultimately, is really up to you.
     # itself has a position, a normal, two texcoords (e.g., diffuse and lightmap),
     # and a color value. Because we've not given Vertex a name (no :Vertex argument
     # to CStruct), it isn't usable as a type for struct members.
-    Vertex = Snow::CStruct[<<END_TYPE]
-      position: Vec3      : 4
-      normal:   Vec3      : 4
-      texcoord: Vec2[2]   : 4
-      color:    Color     : 4
-    END_TYPE
+    Vertex = Snow::CStruct.new {
+      vec3  :position,      align: 4
+      vec3  :normal,        align: 4
+      vec2  :texcoord, [2], align: 4
+      color :color,         align: 4
+    }
+
+    def stringify_vertex(vertex)
+      <<-VERTEX_DESCRIPTION
+      Position:  #{vertex.position.to_h}
+      Normal:    #{vertex.normal.to_h}
+      Texcoords: [#{vertex.texcoord(0).to_h}, #{vertex.texcoord(1).to_h}]
+      Color:     #{vertex.color.to_h}
+      VERTEX_DESCRIPTION
+    end
 
     # So let's create a vertex.
     a_vertex = Vertex.new { |v|
-      v.position = Vec3.new { |p| p.x = 1; p.y = 2; p.z = 3 }
-      v.normal   = Vec3.new { |n| n.x = 0.707107; n.y = 0; n.z = 0.707107 }
+      v.position      = Vec3.new { |p| p.x = 1; p.y = 2; p.z = 3 }
+      v.normal        = Vec3.new { |n| n.x = 0.707107; n.y = 0; n.z = 0.707107 }
       # For array types, we must use set_* functions, as the name= shorthand for
       # struct members only assigns to the first element of an array.
-      v.texcoord = Vec2.new { |t| t.x = 1.0; t.y = 1.0 }
-      # Though if you're masochistic you could also do this:
-      v.__send__(:texcoord=, Vec2.new { |t| t.x = 0.5; t.y = 0.5 }, 1)
-      v.color    = Color.new { |c| c.r = 255; c.g = 127; c.b = 63; c.a = 220 }
+      v.texcoord      = Vec2.new { |t| t.x = 1.0; t.y = 1.0 }
+      # This also works:
+      v[:texcoord, 1] = Vec2.new { |t| t.x = 0.5; t.y = 0.5 }
+      v.color         = Color.new { |c| c.r = 255; c.g = 127; c.b = 63; c.a = 220 }
     }
 
-    puts <<VERTEX_DESCRIPTION
-    Our vertex has the following properties:
-      Position: #{a_vertex.position.to_h}
-      Normal:   #{a_vertex.normal.to_h}
-      Texcoords: [
-        #{a_vertex.texcoord(0).to_h}
-        #{a_vertex.texcoord(1).to_h}
-      ]
-      Color:    #{a_vertex.color.to_h}
-
-    VERTEX_DESCRIPTION
+    puts "Our vertex:\n#{stringify_vertex a_vertex}"
 
     # For kicks, let's create an array.
     some_vertices = Vertex[64]
@@ -90,16 +89,7 @@ How you use it, ultimately, is really up to you.
     # And set all vertices to the above vertex.
     some_vertices.map! { a_vertex }
 
-    puts <<VERTEX_DESCRIPTION
-    Our vertex in the array at index 36 has the following properties:
-      Position: #{some_vertices[36].position.to_h}
-      Normal:   #{some_vertices[36].normal.to_h}
-      Texcoords: [
-        #{some_vertices[36].texcoord(0).to_h}
-        #{some_vertices[36].texcoord(1).to_h}
-      ]
-      Color:    #{some_vertices[36].color.to_h}
-    VERTEX_DESCRIPTION
+    puts "Our vertex at index 36:\n#{stringify_vertex some_vertices[36]}"
 
 
 License
@@ -114,10 +104,10 @@ Snow-Data is licensed under a simplified BSD license, like most of my gems.
     modification, are permitted provided that the following conditions are met:
 
     1. Redistributions of source code must retain the above copyright notice, this
-       list of conditions and the following disclaimer. 
+       list of conditions and the following disclaimer.
     2. Redistributions in binary form must reproduce the above copyright notice,
        this list of conditions and the following disclaimer in the documentation
-       and/or other materials provided with the distribution. 
+       and/or other materials provided with the distribution.
 
     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

data/lib/snow-data/c_struct.rb

@@ -6,6 +6,7 @@ require 'snow-data/snowdata_bindings'
 require 'snow-data/memory'
 require 'snow-data/c_struct/struct_base'
 require 'snow-data/c_struct/array_base'
+require 'snow-data/c_struct/builder'
 
 module Snow
 
@@ -16,6 +17,8 @@ class CStruct
   # Info for a struct member. Defines a member's name, type, size, length,
   # alignment, and offset.
   #
+  # The type member of this may not be an alias of another type.
+  #
   StructMemberInfo = Struct.new(:name, :type, :size, :length, :alignment, :offset)
 
 
@@ -174,7 +177,7 @@ class CStruct
 
   # Used for getters/setters on Memory objects. Simply maps short type names to
   # their long-form type names.
-  LONG_NAMES = {
+  TYPE_ALIASES = {
     # char
     :c      => :char,
     :sc     => :signed_char,
@@ -207,6 +210,37 @@ class CStruct
   }
 
 
+  #
+  # Gets the actual type for a given type. Only useful for deducing the target
+  # type for a type alias.
+  #
+  def self.real_type_of(type)
+    while TYPE_ALIASES.include?(type)
+      type = TYPE_ALIASES[type]
+    end
+    type
+  end
+
+
+  #
+  # Aliases the type for old_name to new_name. Raises
+  #
+  def self.alias_type(new_name, old_name)
+    return self if new_name == old_name
+    old_name = real_type_of(old_name)
+
+    if ! SIZES.include?(old_name)
+      raise ArgumentError, "There is no type named #{old_name} to alias"
+    elsif TYPE_ALIASES.include?(new_name) || SIZES.include?(new_name)
+      raise ArgumentError, "Type <#{new_name}> is already defined in CStruct"
+    end
+
+    TYPE_ALIASES[new_name] = old_name
+    Builder.flush_type_methods!
+    self
+  end
+
+
   #
   # call-seq:
   #     add_type(name, klass) => klass
@@ -215,13 +249,22 @@ class CStruct
   # can be used as a member type by using the name provided to #add_type in
   # struct encodings.
   #
-  def self.add_type(name, klass)
-    name = name.intern
+  def self.add_type(name = nil, klass)
+    raise "Class must be a subclass of #{Memory}" unless Memory > klass
+
+    if ! name
+      name = klass.name
+      if (last_sro = name.rindex('::'))
+        name = name[last_sro + 2, name.length]
+      end
+    end
+
+    name = name.to_sym
 
-    raise "No type name provided" if !name
+    raise "Type for #{name} is already defined" if SIZES.include?(name)
 
     ALIGNMENTS[name] = klass::ALIGNMENT
-    SIZES[name] = klass::SIZE
+    SIZES[name]      = klass::SIZE
 
     getter = :"get_#{name}"
     setter = :"set_#{name}"
@@ -246,6 +289,8 @@ class CStruct
 
     end # class_exec
 
+    Builder.flush_type_methods!
+
     klass
   end
 
@@ -254,6 +299,8 @@ class CStruct
   # call-seq:
   #     new(name, encoding) => Class
   #     new(encoding) => Class
+  #     new(name) { ... } => Class
+  #     new { ... } => Class
   #
   # Creates a new C-struct class and returns it. Optionally, if a name is
   # provided, it is also added as a class under the CStruct class.
@@ -275,6 +322,10 @@ class CStruct
   # call ::add_type(name, klass). This will not register it as a constant under
   # CStruct.
   #
+  # If a block is given, a CStruct::Builder is allocated and the block is
+  # instance_exec'd for that builder. Encoding strings may not be passed if you
+  # opt to use a builder block in place of an encoding string.
+  #
   #
   # ### Encodings
   #
@@ -355,10 +406,30 @@ class CStruct
   # `fetch(index)` and `store(index, value)` methods, both aliased to `[]` and
   # `[]=` respectively.
   #
-  def self.new(klass_name = nil, encoding)
+  def self.new(*args, &block)
+    klass_name = nil
+    encoding = nil
+
+    case
+    when args.length == 0 && block_given?
+      ; #nop
+    when args.length == 1 && block_given?
+      klass_name = args[0]
+    when args.length == 1
+      encoding = args[0]
+    when args.length == 2 && !block_given?
+      klass_name, encoding = *args
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 0..2)"
+    end
+
     klass_name = klass_name.intern if klass_name
 
-    members = decode_member_info(encoding)
+    members = if block_given?
+      Builder.new(&block).member_info
+    else
+      decode_member_info(encoding)
+    end
 
     raise "No valid members found in encoding" if members.empty?
 
@@ -385,8 +456,7 @@ class CStruct
     encoding.scan(ENCODING_REGEX).map do
       |match|
       name        = match[0].intern
-      type        = match[1].intern
-      type        = LONG_NAMES[type] if LONG_NAMES.include?(type)
+      type        = real_type_of(match[1].intern)
       length      = (match[3] || 1).to_i
       align       = (match[5] || ALIGNMENTS[type] || 1).to_i
       size        = SIZES[type] * length
@@ -428,9 +498,9 @@ class CStruct
     members.freeze
 
     # Get the alignment, size, aligned size, and encoding of the struct.
-    alignment = members.map { |member| member.alignment }.max { |lhs, rhs| lhs <=> rhs }
-    size = members.last.size + members.last.offset
-    aligned_size = Memory.align_size(size, alignment)
+    alignment    = members.map { |member| member.alignment }.max { |lhs, rhs| lhs <=> rhs }
+    type_size    = members.last.size + members.last.offset
+    aligned_size = Memory.align_size(type_size, alignment)
     # Oddly enough, it would be easier to pass the encoding string into this
     # function, but then it would ruin the nice little thing I have going where
     # this function isn't dependent on parsing encodings, so we reproduce the
@@ -443,7 +513,7 @@ class CStruct
       # and other methods.
       const_set(:ENCODING,      encoding)
       const_set(:MEMBERS,       members)
-      const_set(:SIZE,          size)
+      const_set(:SIZE,          type_size)
       const_set(:ALIGNED_SIZE,  aligned_size)
       const_set(:ALIGNMENT,     alignment)
 
@@ -492,7 +562,8 @@ class CStruct
 
   class <<self ; alias_method :[], :new ; end
 
-end # class CStruct
+  Builder.flush_type_methods!
 
+end # class CStruct
 
 end # module Snow

data/lib/snow-data/c_struct/builder.rb

@@ -0,0 +1,94 @@
+require 'set'
+
+module Snow ; end
+class Snow::CStruct ; end
+
+class Snow::CStruct::Builder
+
+  @@defined_types = Set.new
+
+  #
+  # call-seq:
+  #     new => Builder
+  #     new { ... } => Builder
+  #
+  # In either form, a new Builder is allocated and returned. If a block is
+  # given, then it will be instance_exec'd, allowing you to easily call any
+  # declaration methods on the builder instance.
+  #
+  def initialize(&block)
+    @members = []
+    @last_offset = 0
+    instance_exec(&block) if block_given?
+  end
+
+  #
+  # call-seq:
+  #     member_info => [StructMemberInfo]
+  #
+  # Returns the StructMemberInfo array for the builder. You should copy this if
+  # you need to modify it, and the same goes for its elements.
+  #
+  def member_info
+    @members
+  end
+
+  #
+  # call-seq:
+  #     flush_type_methods! => self
+  #
+  # Defines methods for declaring members of any recognized CStruct type,
+  # including aliases.
+  #
+  def self.flush_type_methods!
+    ::Snow::CStruct::SIZES.each do |type_name, type_size|
+      next if @@defined_types.include?(type_name)
+
+      method_name = type_name.to_s
+      first_char = method_name[0]
+      case
+      when first_char >= ?A && first_char <= ?Z
+        method_name[0] = first_char.downcase
+      when first_char >= ?0 && first_char <= ?9
+        method_name[0] = "_#{first_char}"
+      end
+      method_name = method_name.to_sym
+
+      __send__(:define_method, method_name) do | name, lengths = 1, align: nil |
+        name = name.to_sym
+
+        length = case lengths
+                 when Integer, Fixnum then lengths
+                 when Array then lengths.reduce(:*)
+                 else lengths.to_i
+                 end
+        raise "Invalid length for member #{name}: must be >= 1" if length < 1
+
+        size = length * type_size
+
+        align = (align || ::Snow::CStruct::ALIGNMENTS[type_name]).to_i
+        raise "Nil alignment for type #{type_name}" if align.nil?
+
+        last_offset = instance_variable_get(:@last_offset)
+        offset = ::Snow::Memory.align_size(last_offset, align)
+        last_offset = offset + size
+
+        member_info = ::Snow::CStruct::StructMemberInfo[
+          name, type_name, size, length, align, offset]
+
+        instance_variable_set(:@last_offset, last_offset)
+        instance_variable_get(:@members).push(member_info.freeze)
+      end # define_method(type_name)
+
+      @@defined_types.add(type_name)
+
+    end # SIZES.each
+
+    ::Snow::CStruct::TYPE_ALIASES.each { |short, long|
+      __send__(:alias_method, short, long)
+    }
+
+    self
+  end # flush_type_methods!
+
+end

data/lib/snow-data/c_struct/struct_base.rb

@@ -96,7 +96,7 @@ module Snow::CStruct::StructBase
     id_text     = __id__.to_s(16).rjust(14, ?0)
     addr_text   = self.address.to_s(16).rjust(14, ?0)
 
-    member_text = if ! null? && CStruct.long_inspect
+    member_text = if ! null? && ::Snow::CStruct.long_inspect
       # Get member text
       all_members_text = (self.class::MEMBERS.map do |member|
         name        = member.name

data/lib/snow-data/version.rb

@@ -7,6 +7,6 @@ module Snow
   #
   # The snow-data version string.
   #
-  SNOW_DATA_VERSION = '1.1.0'.freeze
+  SNOW_DATA_VERSION = '1.2.0'.freeze
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: snow-data
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Noel Raymond Cower
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2013-07-20 00:00:00.000000000 Z
 dependencies: []
 description: |
   Snow-Data is a gem for allocating memory and working with existing blocks of
@@ -25,6 +25,7 @@ extra_rdoc_files:
 - COPYING
 files:
 - lib/snow-data/c_struct/array_base.rb
+- lib/snow-data/c_struct/builder.rb
 - lib/snow-data/c_struct/struct_base.rb
 - lib/snow-data/c_struct.rb
 - lib/snow-data/memory.rb