ffi-msgpack 0.1.0

data/lib/ffi/msgpack/msg_key_value.rb

@@ -0,0 +1,33 @@
+require 'ffi/msgpack/types'
+require 'ffi/msgpack/msg_object'
+
+module FFI
+  module MsgPack
+    class MsgKeyValue < FFI::Struct
+
+      layout :key, :pointer,
+             :value, :pointer
+
+      #
+      # The key.
+      #
+      # @return [MsgObject]
+      #   The key Msg Object.
+      #
+      def key
+        MsgObject.new(self[:key])
+      end
+
+      #
+      # The value.
+      #
+      # @return [MsgObject]
+      #   The value Msg Object.
+      #
+      def value
+        MsgObject.new(self[:value])
+      end
+
+    end
+  end
+end

data/lib/ffi/msgpack/msg_map.rb

@@ -0,0 +1,41 @@
+require 'ffi/msgpack/types'
+require 'ffi/msgpack/msg_key_value'
+
+module FFI
+  module MsgPack
+    class MsgMap < FFI::Struct
+
+      layout :size, :uint32,
+             :ptr, :pointer
+
+      #
+      # The length of the MsgPack Array.
+      #
+      # @return [Integer]
+      #   The length of the Array.
+      #
+      def length
+        self[:size]
+      end
+
+      #
+      # The Hash of the Msg Maps keys and values.
+      #
+      # @return [Hash]
+      #   The Hash of the key->value values.
+      #
+      def to_hash
+        hash = {}
+
+        (0...self.length).each do |index|
+          pair = MsgKeyValue.new(self[:ptr][index * MsgKeyValue.size])
+
+          hash[pair.key.to_ruby] = pair.value.to_ruby
+        end
+
+        return hash
+      end
+
+    end
+  end
+end

data/lib/ffi/msgpack/msg_object.rb

@@ -0,0 +1,276 @@
+require 'ffi/msgpack/types'
+require 'ffi/msgpack/msg_object_union'
+
+module FFI
+  module MsgPack
+    class MsgObject < FFI::Struct
+
+      layout :type, :msgpack_object_type,
+             :values, MsgObjectUnion
+
+      #
+      # Creates a new `nil` Msg Object.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to create the Msg Object at.
+      #
+      # @return [MsgObject]
+      #   A new Msg Object that represents the `nil` value.
+      #
+      def MsgObject.new_nil(ptr=nil)
+        obj = MsgObject.new(ptr)
+        obj[:type] = :nil
+
+        return obj
+      end
+
+      #
+      # Creates a new boolean Msg Object.
+      #
+      # @param [Boolean] value
+      #   The boolean value.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to create the Msg Object at.
+      #
+      # @return [MsgObject]
+      #   The new boolean Msg Object.
+      #
+      def MsgObject.new_boolean(value,ptr=nil)
+        obj = MsgObject.new(ptr)
+        obj[:type] = :boolean
+        obj[:values][:boolean] = if value
+                                   1
+                                 else
+                                   0
+                                 end
+
+        return obj
+      end
+
+      #
+      # Creates a new integer Msg Object.
+      #
+      # @param [Integer] value
+      #   The integer value.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to create the Msg Object at.
+      #
+      # @return [MsgObject]
+      #   The new integer Msg Object.
+      #
+      def MsgObject.new_integer(value,ptr=nil)
+        obj = MsgObject.new(ptr)
+
+        if value < 0
+          obj[:type] = :negative_integer
+          obj[:values][:i64] = value
+        else
+          obj[:type] = :positive_integer
+          obj[:values][:u64] = value
+        end
+
+        return obj
+      end
+
+      #
+      # Creates a new floating-point Msg Object.
+      #
+      # @param [Double, Float] value
+      #   The floating-point value.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to create the Msg Object at.
+      #
+      # @return [MsgObject]
+      #   The floating-point Msg Object.
+      #
+      def MsgObject.new_double(value,ptr=nil)
+        obj = MsgObject.new(ptr)
+        obj[:type] = :double
+        obj[:values][:dec] = value
+
+        return obj
+      end
+
+      #
+      # @see MsgObject.new_double
+      #
+      def MsgObject.new_float(value,ptr=nil)
+        MsgObject.new_double(value,ptr)
+      end
+
+      #
+      # Creates a new raw Msg Object.
+      #
+      # @param [String] data
+      #   The raw data.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to create the Msg Object at.
+      #
+      # @return [MsgObject]
+      #   The raw Msg Object.
+      #
+      def MsgObject.new_raw(data,ptr=nil)
+        buffer = FFI::MemoryPointer.new(:uchar, data.length)
+        buffer.put_bytes(0,data)
+
+        obj = MsgObject.new(ptr)
+        obj[:type] = :raw
+        obj[:values][:raw][:size] = data.length
+        obj[:values][:raw][:ptr] = buffer
+
+        return obj
+      end
+
+      #
+      # Creates a new array Msg Object.
+      #
+      # @param [Array] values
+      #   The values for the array.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to create the Msg Object at.
+      #
+      # @return [MsgObject]
+      #   The array Msg Object.
+      #
+      def MsgObject.new_array(values,ptr=nil)
+        entries = FFI::MemoryPointer.new(MsgObject,values.length)
+
+        values.each_with_index do |value,index|
+          MsgObject.new_object(value,entries[index])
+        end
+
+        obj = MsgObject.new(ptr)
+        obj[:type] = :array
+        obj[:values][:array][:size] = values.length
+        obj[:values][:array][:ptr] = entries
+
+        return obj
+      end
+
+      #
+      # Creates a new map Msg Object.
+      #
+      # @param [Hash] values
+      #   The values for the map.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to create the Msg Object at.
+      #
+      # @return [MsgObject]
+      #   The map Msg Object.
+      #
+      def MsgObject.new_map(values,ptr=nil)
+        entries = FFI::MemoryPointer.new(MsgKeyValue,values.length)
+
+        values.each_with_index do |(key,value),index|
+          pair = MsgKeyValue.new(entries[index])
+
+          pair[:key] = MsgObject.new_object(key)
+          pair[:value] = MsgObject.new_object(value)
+        end
+
+        obj = MsgObject.new
+        obj[:type] = :map
+        obj[:values][:map][:size] = values.length
+        obj[:values][:map][:ptr] = entries
+
+        return obj
+      end
+
+      #
+      # Creates a Msg Object from a given Ruby object.
+      #
+      # @param [Object] value
+      #   The Ruby object.
+      #
+      # @param [FFI::Pointer] ptr
+      #   Optional pointer to create the Msg Object at.
+      #
+      # @return [MsgObject]
+      #   The new Msg Object.
+      #
+      def MsgObject.new_object(value,ptr=nil)
+        case value
+        when Hash
+          MsgObject.new_map(value,ptr)
+        when Array
+          MsgObject.new_array(value,ptr)
+        when String, Symbol
+          MsgObject.new_raw(value.to_s,ptr)
+        when Float
+          MsgObject.new_double(value,ptr)
+        when Integer
+          MsgObject.new_integer(value,ptr)
+        when TrueClass, FalseClass
+          MsgObject.new_boolean(value,ptr)
+        when NilClass
+          MsgObject.new_nil(ptr)
+        else
+          raise(ArgumentError,"ambigious object to create MsgObject from: #{value.inspect}",caller)
+        end
+      end
+
+      #
+      # The type of the Msg Object.
+      #
+      # @return [Symbol]
+      #   The type of the Msg Object.
+      #
+      def type
+        self[:type]
+      end
+
+      #
+      # The union of values for the Msg Object.
+      #
+      # @return [MsgObjectUnion]
+      #   The union of values.
+      #
+      def values
+        self[:values]
+      end
+
+      #
+      # The value of the Msg Object.
+      #
+      # @return [Object]
+      #   The value of the Msg Object, expressed as a Ruby primitive.
+      #
+      # @raise [RuntimeError]
+      #   The type of the Msg Object was unknown.
+      #
+      def to_ruby
+        case self[:type]
+        when :nil
+          nil
+        when :boolean
+          if self[:values][:boolean] == 0
+            false
+          else
+            true
+          end
+        when :positive_integer
+          self[:values][:u64]
+        when :negative_integer
+          self[:values][:i64]
+        when :double
+          self[:values][:dec]
+        when :raw
+          self[:values][:raw].to_s
+        when :array
+          self[:values][:array].to_a
+        when :map
+          self[:values][:map].to_hash
+        else
+          raise(RuntimeError,"unknown msgpack object type",caller)
+        end
+      end
+
+    end
+  end
+end

data/lib/ffi/msgpack/msg_object_union.rb

@@ -0,0 +1,20 @@
+require 'ffi/msgpack/types'
+require 'ffi/msgpack/msg_array'
+require 'ffi/msgpack/msg_map'
+require 'ffi/msgpack/msg_raw'
+
+module FFI
+  module MsgPack
+    class MsgObjectUnion < FFI::Union
+
+      layout :boolean, :uint8,
+             :u64, :uint64,
+             :i64, :int64,
+             :dec, :double,
+             :array, MsgArray,
+             :map, MsgMap,
+             :raw, MsgRaw
+
+    end
+  end
+end

data/lib/ffi/msgpack/msg_raw.rb

@@ -0,0 +1,42 @@
+require 'ffi/msgpack/types'
+
+module FFI
+  module MsgPack
+    class MsgRaw < FFI::Struct
+
+      layout :size, :uint32,
+             :ptr, :pointer
+
+      #
+      # The length of the raw data.
+      #
+      # @return [Integer]
+      #   The length of the raw data.
+      #
+      def length
+        self[:size]
+      end
+
+      #
+      # The pointer to the raw data.
+      #
+      # @return [FFI::Pointer]
+      #   The pointer to the raw data.
+      #
+      def raw
+        self[:ptr]
+      end
+
+      #
+      # The raw data.
+      #
+      # @return [String]
+      #   The raw data.
+      #
+      def to_s
+        self[:ptr].get_bytes(0,self[:size])
+      end
+
+    end
+  end
+end

data/lib/ffi/msgpack/msgpack.rb

@@ -0,0 +1,127 @@
+require 'ffi/msgpack/types'
+require 'ffi/msgpack/msg_object'
+
+require 'ffi'
+require 'enumerator'
+
+module FFI
+  module MsgPack
+    extend FFI::Library
+
+    ffi_lib 'msgpack'
+
+    attach_function :msgpack_object_print, [:pointer, MsgObject.by_value], :void
+    #attach_function :msgpack_object_equal, [MsgObject, MsgObject.by_value], :bool
+
+    attach_function :msgpack_zone_init, [:pointer, :size_t], :bool
+    attach_function :msgpack_zone_destroy, [:pointer], :void
+    attach_function :msgpack_zone_new, [:size_t], :pointer
+    attach_function :msgpack_zone_free, [:pointer], :void
+    attach_function :msgpack_zone_is_empty, [:pointer], :bool
+    attach_function :msgpack_zone_clear, [:pointer], :void
+
+    attach_function :msgpack_unpacker_init, [:pointer, :size_t], :bool
+    attach_function :msgpack_unpacker_destroy, [:pointer], :void
+
+    attach_function :msgpack_unpacker_new, [:size_t], :pointer
+    attach_function :msgpack_unpacker_free, [:pointer], :void
+
+    #attach_function :msgpack_unpacker_reserve_buffer, [:pointer, :size_t], :bool
+    #attach_function :msgpack_unpacker_buffer, [:pointer], :pointer
+    #attach_function :msgpack_unpacker_buffer_capacity, [:pointer], :size_t
+    #attach_function :msgpack_unpacker_buffer_consumed, [:pointer, :size_t], :void
+
+    attach_function :msgpack_unpacker_execute, [:pointer], :int
+
+    attach_function :msgpack_unpacker_data, [:pointer], MsgObject.by_value
+
+    attach_function :msgpack_unpacker_release_zone, [:pointer], :pointer
+
+    attach_function :msgpack_unpacker_reset_zone, [:pointer], :void
+
+    attach_function :msgpack_unpacker_reset, [:pointer], :void
+
+    #attach_function :msgpack_unpacker_message_size, [:pointer], :size_t
+
+    attach_function :msgpack_unpack, [:pointer, :size_t, :pointer, :pointer, :pointer], :msgpack_unpack_return
+
+    #attach_function :msgpack_unpacker_parsed_size, [:pointer], :size_t
+
+    attach_function :msgpack_unpacker_flush_zone, [:pointer], :bool
+
+    attach_function :msgpack_unpacker_expand_buffer, [:pointer, :size_t], :bool
+
+    #attach_function :msgpack_packer_init, [:pointer, :pointer, :msgpack_packer_write], :void
+
+    #attach_function :msgpack_packer_new, [:pointer, :msgpack_packer_write], :pointer
+    #attach_function :msgpack_packer_free, [:pointer], :void
+
+    #attach_function :msgpack_pack_short, [:pointer, :short], :int
+    #attach_function :msgpack_pack_int, [:pointer, :int], :int
+    #attach_function :msgpack_pack_long, [:pointer, :long], :int
+    #attach_function :msgpack_pack_long_long, [:pointer, :int64], :int
+    #attach_function :msgpack_pack_unsigned_short, [:pointer, :ushort], :int
+    #attach_function :msgpack_pack_unsigned_int, [:pointer, :uint], :int
+    #attach_function :msgpack_pack_unsigned_long, [:pointer, :ulong], :int
+    #attach_function :msgpack_pack_unsigned_long_long, [:pointer, :uint64], :int
+
+    #attach_function :msgpack_pack_uint8, [:pointer, :uint8], :int
+    #attach_function :msgpack_pack_uint16, [:pointer, :uint16], :int
+    #attach_function :msgpack_pack_uint32, [:pointer, :uint32], :int
+    #attach_function :msgpack_pack_uint64, [:pointer, :uint64], :int
+    #attach_function :msgpack_pack_int8, [:pointer, :int8], :int
+    #attach_function :msgpack_pack_int16, [:pointer, :int16], :int
+    #attach_function :msgpack_pack_int32, [:pointer, :int32], :int
+    #attach_function :msgpack_pack_int64, [:pointer, :int64], :int
+
+    #attach_function :msgpack_pack_float, [:pointer, :float], :int
+    #attach_function :msgpack_pack_double, [:pointer, :double], :int
+
+    #attach_function :msgpack_pack_nil, [:pointer], :int
+    #attach_function :msgpack_pack_true, [:pointer], :int
+    #attach_function :msgpack_pack_false, [:pointer], :int
+
+    #attach_function :msgpack_pack_array, [:pointer, :uint], :int
+
+    #attach_function :msgpack_pack_map, [:pointer, :uint], :int
+
+    #attach_function :msgpack_pack_raw, [:pointer, :size_t], :int
+
+    #attach_function :msgpack_pack_raw_body, [:pointer, :pointer, :size_t], :int
+
+    attach_function :msgpack_pack_object, [:pointer, MsgObject.by_value], :int
+
+    #
+    # Packs a Ruby object.
+    #
+    # @param [Hash, Array, String, Symbol, Integer, Float, true, false, nil] obj
+    #   The Ruby object to pack.
+    #
+    # @return [String]
+    #   The packed Ruby object.
+    #
+    def MsgPack.pack(obj)
+      packer = Packer.create
+      packer << obj
+
+      return packer.to_s
+    end
+
+    #
+    # Unpacks a packed object.
+    #
+    # @param [String] packed
+    #   The packed object.
+    #
+    # @return [Hash, Array, String, Symbol, Integer, Float, true, false, nil]
+    #   The first unpacked Ruby object.
+    #
+    def MsgPack.unpack(packed)
+      unpacker = Unpacker.create(packed.length)
+      unpacker << packed
+
+      return unpacker.first
+    end
+
+  end
+end