ffi-czmq 0.0.9.pre → 0.1.1.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d7bc5dbfbbab88b01da91de2d64910c29d5230e
-  data.tar.gz: 996a30caf32c11dd341ecda967bcfdb1a44766dd
+  metadata.gz: c194cff3d41eae0f11f28592e0f941af8202e66c
+  data.tar.gz: ba4b758beb7306b357ac680f61b9ee2ba778468f
 SHA512:
-  metadata.gz: 0247ce7e0940e2ab8661e98935a8bcc780c7362bfa6a8878db03c21aa84e542230f3679f3d6d730aedf2b78a3c502348b34371e4a0433e6500ee7025af219b6a
-  data.tar.gz: 15a1dc2f33b43609b1657773ed649848530ab6e8d76cc8fafeca0d378ede15b054a2250a7f64631d6130d7232cc7010b4b081cbc46352493b51dedf9b51d3062
+  metadata.gz: 6789dc075cc8cc874b6035187e5db349c34fc92dec5ce60400658e0f59c4e9f36aedfce79fc4a0f3d548216bf4e4bd8e2337a67fcb00feb08cba99922189418b
+  data.tar.gz: 1394af326de53f42e345d6d92515ab82b59c2ad24c04038987c1a7c5142a868388165607167426336a3f5c02f1bb09eea3d7d4af22c787e16bb34e51d57ccae4

data/LICENSE

@@ -175,17 +175,6 @@ Apache License
 
    END OF TERMS AND CONDITIONS
 
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
    Copyright 2014 Hendrik Beskow
 
    Licensed under the Apache License, Version 2.0 (the "License");

data/lib/czmq/utils.rb

@@ -9,20 +9,20 @@ module CZMQ
 
     attach_function :zmq_version,   :zmq_version,     [:buffer_in, :buffer_in, :buffer_in], :void,    blocking: true
     attach_function :zsys_version,  :zsys_version,    [:buffer_in, :buffer_in, :buffer_in], :void,    blocking: true
-    attach_function :errno,         :zmq_errno,       [],                                   :int,     blocking: true
-    attach_function :strerror,      :zmq_strerror,    [:int],                               :string,  blocking: true
+    attach_function :errno,         :zmq_errno,       [],                                   :int
+    attach_function :strerror,      :zmq_strerror,    [:int],                               :string
 
     module_function
 
     def version
       unless @version
-        z_major = FFI::MemoryPointer.new :int
-        z_minor = FFI::MemoryPointer.new :int
-        z_patch = FFI::MemoryPointer.new :int
+        z_major = FFI::MemoryPointer.new :pointer
+        z_minor = FFI::MemoryPointer.new :pointer
+        z_patch = FFI::MemoryPointer.new :pointer
 
-        c_major = FFI::MemoryPointer.new :int
-        c_minor = FFI::MemoryPointer.new :int
-        c_patch = FFI::MemoryPointer.new :int
+        c_major = FFI::MemoryPointer.new :pointer
+        c_minor = FFI::MemoryPointer.new :pointer
+        c_patch = FFI::MemoryPointer.new :pointer
 
         zmq_version  z_major, z_minor, z_patch
         zsys_version c_major, c_minor, c_patch
@@ -54,8 +54,6 @@ module CZMQ
 
     if version[:czmq][:major] < 3
       fail LoadError, 'This needs at least czmq 3'
-    else
-      attach_function :has_curve, :zsys_has_curve,  [], :bool,  blocking: true
     end
   end
 end

data/lib/czmq/version.rb

@@ -1,3 +1,3 @@
 module CZMQ
-  VERSION = Gem::Version.new('0.0.9.pre')
+  VERSION = Gem::Version.new('0.1.1.pre')
 end

data/lib/czmq/zactor.rb

@@ -13,14 +13,13 @@ module CZMQ
     czmq_function   :resolve,     :resolve,   [:pointer],           :pointer
     attach_function :zauth,       :zauth,     [:pointer, :pointer], :void, blocking: true
     attach_function :zbeacon,     :zbeacon,   [:pointer, :pointer], :void, blocking: true
-    attach_function :zgossip,     :zgossip,   [:pointer, :pointer], :void, blocking: true
+    attach_function :zgossip,     :zgossip,   [:pointer, :string],  :void, blocking: true
     attach_function :zmonitor,    :zmonitor,  [:pointer, :pointer], :void, blocking: true
     attach_function :zproxy,      :zproxy,    [:pointer, :pointer], :void, blocking: true
 
     def self.new_actor(&actor)
       zactor_fn = FFI::Function.new(:void, [:pointer, :pointer], blocking: true) do |zsock_t, args|
-        child_pipe = Zsock.new_from_czmq_obj(zsock_t, nil)
-        actor.call(child_pipe)
+        yield Zsock.new_from_czmq_obj(zsock_t, nil)
       end
 
       new(zactor_fn, nil)
@@ -28,30 +27,24 @@ module CZMQ
 
     [:zauth, :zbeacon, :zproxy].each do |meth|
       instance_eval <<-RUBY, __FILE__, __LINE__
-      def new_#{meth.to_s}
-        zactor_fn = FFI::Function.new(:void, [:pointer, :pointer], blocking: true) do |zsock_t, args|
-          #{meth.to_s}(zsock_t, args)
-        end
+      const_set("#{meth.to_s.upcase}", FFI::Function.new(:void, [:pointer, :pointer], blocking: true) {|zsock_t, args| #{meth.to_s}(zsock_t, args)})
 
-        new(zactor_fn, nil)
+      def new_#{meth.to_s}
+        new(#{meth.to_s.upcase}, nil)
       end
       RUBY
     end
 
-    def self.new_zmonitor(sock)
-      zactor_fn = FFI::Function.new(:void, [:pointer, :pointer], blocking: true) do |zsock_t, args|
-        zmonitor(zsock_t, args)
-      end
+    ZMONITOR = FFI::Function.new(:void, [:pointer, :pointer], blocking: true) {|zsock_t, args| zmonitor(zsock_t, args)}
 
-      new(zactor_fn, Zsock.convert(sock))
+    def self.new_zmonitor(sock)
+      new(ZMONITOR, Zsock.convert(sock))
     end
 
-    def self.new_zgossip(logprefix)
-      zactor_fn = FFI::Function.new(:void, [:pointer, :string], blocking: true) do |zsock_t, args|
-        zgossip(zsock_t, args)
-      end
+    ZGOSSIP = FFI::Function.new(:void, [:pointer, :string], blocking: true) {|zsock_t, args| zgossip(zsock_t, args)}
 
-      new(zactor_fn, logprefix)
+    def self.new_zgossip(logprefix)
+      new(ZGOSSIP, logprefix)
     end
 
     def tell(*msgs)

data/lib/czmq/zcert.rb

@@ -1,56 +1,54 @@
 require_relative 'utils'
 require_relative 'libczmq'
 
-if CZMQ::Utils.has_curve
-  module CZMQ
-    class Zcert
-      extend ::LibCZMQ
-
-      czmq_constructor
-      czmq_destructor
-
-      czmq_function :public_txt,  :public_txt,  [:pointer],           :string
-      czmq_function :secret_txt,  :secret_txt,  [:pointer],           :string
-      czmq_function :load_zcert,  :load,        [:string],            :pointer
-      czmq_function :save,        :save,        [:pointer, :string],  :int
-      czmq_function :save_public, :save_public, [:pointer, :string],  :int
-      czmq_function :save_secret, :save_secret, [:pointer, :string],  :int
-      czmq_function :apply,       :apply,       [:pointer, :pointer], :void
-      czmq_function :dup_zcert,   :dup,         [:pointer],           :pointer
-      czmq_function :eq,          :eq,          [:pointer, :pointer], :bool
-
-      def self.convert(cert)
-        if Utils.check_for_pointer(cert)
-
-          return cert
-        elsif cert.respond_to?(:to_zcert) &&
-              Utils.check_for_pointer(cert.to_zcert)
-
-          return cert.to_zcert
-        else
-          fail ArgumentError, "#{cert.class} is not a CZMQ::Zcert", caller
-        end
+module CZMQ
+  class Zcert
+    extend ::LibCZMQ
+
+    czmq_constructor
+    czmq_destructor
+
+    czmq_function :public_txt,  :public_txt,  [:pointer],           :string
+    czmq_function :secret_txt,  :secret_txt,  [:pointer],           :string
+    czmq_function :load_zcert,  :load,        [:string],            :pointer
+    czmq_function :save,        :save,        [:pointer, :string],  :int
+    czmq_function :save_public, :save_public, [:pointer, :string],  :int
+    czmq_function :save_secret, :save_secret, [:pointer, :string],  :int
+    czmq_function :apply,       :apply,       [:pointer, :pointer], :void
+    czmq_function :dup_zcert,   :dup,         [:pointer],           :pointer
+    czmq_function :eq,          :eq,          [:pointer, :pointer], :bool
+
+    def self.convert(cert)
+      if Utils.check_for_pointer(cert)
+
+        return cert
+      elsif cert.respond_to?(:to_zcert) &&
+            Utils.check_for_pointer(cert.to_zcert)
+
+        return cert.to_zcert
+      else
+        fail ArgumentError, "#{cert.class} is not a CZMQ::Zcert", caller
       end
+    end
 
-      def self.load(filename)
-        unless (zcert = load_zcert(filename)).null?
-          new_from_czmq_obj(zcert)
-        else
-          fail IOError, Utils.error, caller
-        end
+    def self.load(filename)
+      unless (zcert = load_zcert(filename)).null?
+        new_from_czmq_obj(zcert)
+      else
+        fail IOError, Utils.error, caller
       end
+    end
 
-      def dup
-        self.class.new_from_czmq_obj(dup_zcert)
-      end
+    def dup
+      self.class.new_from_czmq_obj(dup_zcert)
+    end
 
-      def ==(other)
-        eq(self.class.convert(other))
-      end
+    def ==(other)
+      (object_id == other.object_id ||eq(self.class.convert(other)))
+    end
 
-      def !=(other)
-        ! self.==(other)
-      end
+    def !=(other)
+      ! self.==(other)
     end
   end
 end

data/lib/czmq/zcertstore.rb

@@ -1,16 +1,14 @@
 require_relative 'utils'
 require_relative 'libczmq'
 
-if CZMQ::Utils.has_curve
-  module CZMQ
-    class Zcertstore
-      extend ::LibCZMQ
+module CZMQ
+  class Zcertstore
+    extend ::LibCZMQ
 
-      czmq_constructor [:string]
-      czmq_destructor
+    czmq_constructor [:string]
+    czmq_destructor
 
-      czmq_function :lookup,        :lookup,  [:pointer, :string],  :pointer
-      czmq_function :insert_zcert,  :insert,  [:pointer, :pointer], :void
-    end
+    czmq_function :lookup,        :lookup,  [:pointer, :string],  :pointer
+    czmq_function :insert_zcert,  :insert,  [:pointer, :pointer], :void
   end
 end

data/lib/czmq/zclock.rb

@@ -0,0 +1,30 @@
+require_relative 'libczmq'
+require_relative 'zstr'
+
+module CZMQ
+  class Zclock
+    extend ::LibCZMQ
+
+    czmq_function :sleep,   :sleep,   [:int], :void
+    czmq_function :time,    :time,    [],     :int64
+    czmq_function :mono,    :mono,    [],     :int64
+    czmq_function :usecs,   :usecs,   [],     :int64
+    czmq_function :timestr, :timestr, [],     :pointer
+
+    def self.time_str
+      Zstr.read_string(timestr)
+    end
+
+    def self.test(verbose = false)
+      start = Zclock.time
+      Zclock.sleep 10
+      raise unless (Zclock.time - start) >= 10
+      start = Zclock.mono
+      usecs = Zclock.usecs
+      Zclock.sleep 10
+      raise unless (Zclock.mono - start) >= 10
+      raise unless (Zclock.usecs - usecs) >= 10000
+      puts time_str if verbose
+    end
+  end
+end

data/lib/czmq/zconfig.rb

@@ -44,7 +44,7 @@ module CZMQ
     def execute(&block)
       zconfig_fct = FFI::Function.new(:int, [:pointer, :pointer, :int], blocking: true) do |zconfig_t, args, level|
         zconfig = self.class.new_from_czmq_obj(zconfig_t, nil)
-        block.call(zconfig, level)
+        yield zconfig, level
       end
 
       execute_zconfig(zconfig_fct, nil)

data/lib/czmq/zframe.rb

@@ -1,5 +1,6 @@
 require_relative 'libczmq'
 require_relative 'utils'
+require_relative 'zstr'
 require_relative 'zsock'
 
 module CZMQ
@@ -20,8 +21,10 @@ module CZMQ
     czmq_function :size,              :size,      [:pointer],                       :size_t
     czmq_function :data,              :data,      [:pointer],                       :pointer
     czmq_function :dup_zframe,        :dup,       [:pointer],                       :pointer
-    czmq_function :more,              :more,      [:pointer],                       :int
-    czmq_function :set_more,          :set_more,  [:pointer, :int],                 :void
+    czmq_function :strhex,            :strhex,    [:pointer],                       :pointer
+    czmq_function :strdup,            :strdup,    [:pointer],                       :pointer
+    czmq_function :more,              :more,      [:pointer],                       :bool
+    czmq_function :set_more,          :set_more,  [:pointer, :bool],                :void
     czmq_function :eq,                :eq,        [:pointer, :pointer],             :bool
     czmq_function :reset,             :reset,     [:pointer, :buffer_in, :size_t],  :void
     czmq_function :print,             :print,     [:pointer, :string],              :void
@@ -51,8 +54,16 @@ module CZMQ
       self.class.new_from_czmq_obj(dup_zframe)
     end
 
+    def str_hex
+      Zstr.read_string(strhex)
+    end
+
+    def str_dup
+      Zstr.read_string(strdup)
+    end
+
     def more?
-      more & MORE > 0
+      more
     end
 
     def <=>(other)

data/lib/czmq/zlogger.rb

@@ -0,0 +1,25 @@
+require_relative 'zsys'
+
+module CZMQ
+  class Zlogger
+    def fatal(message)
+      Zsys.error(message)
+    end
+    
+    def error(message)
+      Zsys.warning(message)
+    end
+    
+    def warn(message)
+      Zsys.notice(message)
+    end
+    
+    def info(message)
+      Zsys.info(message)
+    end
+    
+    def debug(message)
+      Zsys.debug(message)
+    end
+  end
+end

data/lib/czmq/zloop.rb

@@ -17,37 +17,36 @@ module CZMQ
     czmq_function :start,         :start,         [:pointer],                                       :int
 
     def initialize
-      @reader_callbacks = []
-      @timer_callbacks  = []
+      @reader_callbacks = {}
+      @timer_callbacks  = {}
     end
 
     def add_reader(zsock, &block)
       zloop_reader_fn = FFI::Function.new(:int, [:pointer, :pointer, :pointer], blocking: true) do |zloop_t, zsock_t, args|
-        zsocky = Zsock.new_from_czmq_obj(zsock_t, nil)
-        block.call(zsocky)
+        yield Zsock.new_from_czmq_obj(zsock_t, nil)
       end
 
       reader(Zsock.convert(zsock), zloop_reader_fn, nil)
-      @reader_callbacks << {zsock: zsock, zloop_reader_fn: zloop_reader_fn, block: block}
+      @reader_callbacks[zloop_reader_fn] = zsock
     end
 
     def remove_reader(zsock)
-      @reader_callbacks.delete_if {|reader| reader[:zsock] == zsock}
+      @reader_callbacks.delete_if {|reader, sock| sock == zsock}
       reader_end(Zsock.convert(zsock))
     end
 
     def add_timer(delay, times, &block)
       zloop_timer_fn = FFI::Function.new(:int, [:pointer, :int, :pointer], blocking: true) do |zloop_t, timer_id, args|
-        block.call(timer_id)
+        yield timer_id
       end
 
       timer_id = timer(delay, times, zloop_timer_fn, nil)
-      @timer_callbacks << {timer_id: timer_id, delay: delay, times: times, zloop_timer_fn: zloop_timer_fn, block: block}
+      @timer_callbacks[timer_id] = zloop_timer_fn
       timer_id
     end
 
     def remove_timer(timer_id)
-      @timer_callbacks.delete_if {|timer| timer[:timer_id] == timer_id}
+      @timer_callbacks.delete(timer_id)
       timer_end(timer_id)
     end
   end

data/lib/czmq/zmsg.rb

@@ -54,7 +54,7 @@ module CZMQ
       when Zframe
         append_zframe(data)
       when String
-        add_string(data)
+        add_mem(data, data.bytesize)
       when Fixnum
         add_zstrf(INTF, :ssize_t, data)
       when NilClass
@@ -71,7 +71,7 @@ module CZMQ
 
           add_mem(data.data, data.size)
         elsif data.respond_to?(:to_str)
-          add_string(data.to_str)
+          add_mem(data.to_str, data.to_str.bytesize)
         elsif data.nil?
           add_mem(nil, 0)
         else
@@ -90,7 +90,7 @@ module CZMQ
       when Zframe
         prepend_zframe(data)
       when String
-        push_string(data)
+        push_mem(data, data.bytesize)
       when Fixnum
         push_zstrf(INTF, :ssize_t, data)
       when NilClass
@@ -107,7 +107,7 @@ module CZMQ
 
           push_mem(data.data, data.size)
         elsif data.respond_to?(:to_str)
-          push_string(data.to_str)
+          push_mem(data.to_str, data.to_str.bytesize)
         elsif data.nil?
           push_mem(nil, 0)
         else
@@ -165,23 +165,5 @@ module CZMQ
     def self.decode(bytes)
       new_from_czmq_obj(decode_zmsg(bytes, bytes.bytesize))
     end
-
-    private
-
-    def add_string(string)
-      if string.encoding == Encoding::ASCII_8BIT
-        add_mem(string, string.size)
-      else
-        add_zstr(string)
-      end
-    end
-
-    def push_string(string)
-      if string.encoding == Encoding::ASCII_8BIT
-        push_mem(string, string.size)
-      else
-        push_zstr(string)
-      end
-    end
   end
 end

data/lib/czmq/zpoller.rb

@@ -1,10 +1,11 @@
 require_relative 'libczmq'
+require_relative 'zsock'
 
 module CZMQ
   class Zpoller
     extend ::LibCZMQ
 
-    czmq_constructor [:pointer, :varargs]
+    czmq_constructor [:varargs]
     czmq_destructor
 
     czmq_function :add,         :add,         [:pointer,  :pointer],  :int
@@ -20,12 +21,11 @@ module CZMQ
 
       zsocks = []
       pollitems.each do |pollitem|
+        zsocks << :pointer
         zsocks << Zsock.convert(pollitem)
       end
 
-      first_sock = zsocks.delete(zsocks.first)
-      other_socks = ([ :pointer ] * zsocks.size).zip(zsocks).flatten
-      new(first_sock, *other_socks, :pointer, nil)
+      new(*zsocks, :pointer, nil)
     end
   end
 end

data/lib/czmq/zsock.rb

@@ -42,9 +42,9 @@ module CZMQ
 
     [:rep, :router, :pull, :pub, :xpub].each do |meth|
       instance_eval <<-RUBY, __FILE__, __LINE__
-      def new_#{meth.to_s}(endpoints)
-        sock = new(#{meth.inspect}, endpoints)
-        sock.attach(endpoints, true)
+      def new_#{meth.to_s}(endpoint)
+        sock = new(#{meth.inspect}, endpoint)
+        sock.attach(endpoint, true)
         sock
       end
       RUBY
@@ -52,20 +52,18 @@ module CZMQ
 
     [:req, :dealer, :push, :xsub, :pair, :stream].each do |meth|
       instance_eval <<-RUBY, __FILE__, __LINE__
-      def new_#{meth.to_s}(endpoints)
-        sock = new(#{meth.inspect}, endpoints)
-        sock.attach(endpoints, false)
+      def new_#{meth.to_s}(endpoint)
+        sock = new(#{meth.inspect}, endpoint)
+        sock.attach(endpoint, false)
         sock
       end
       RUBY
     end
 
-    def self.new_sub(endpoints, *subscriptions)
-      sock = new(:sub, endpoints, *subscriptions)
-      sock.attach(endpoints, false)
-      subscriptions.each do |subscription|
-        sock.set_subscribe(subscription)
-      end
+    def self.new_sub(endpoint, subscribe = nil)
+      sock = new(:sub, endpoint)
+      sock.attach(endpoint, false)
+      sock.set_subscribe(subscribe) if subscribe
       sock
     end
 

data/lib/czmq/zstr.rb

@@ -15,15 +15,11 @@ module CZMQ
 
     class << self
       def read_string(str_ptr)
-        if Utils.check_for_pointer(str_ptr)
-          str = str_ptr.read_string
-          free_ptr = FFI::MemoryPointer.new(:pointer)
-          free_ptr.write_pointer(str_ptr)
-          free(free_ptr)
-          str
-        else
-          fail ArgumentError, "#{str_ptr.class} is not a FFI::Pointer", caller
-        end
+        str = str_ptr.get_string(0)
+        free_ptr = FFI::MemoryPointer.new(:pointer)
+        free_ptr.write_pointer(str_ptr)
+        free(free_ptr)
+        str
       end
 
       def recv(socket)
@@ -31,7 +27,7 @@ module CZMQ
       end
 
       def sendx(socket, string, *strings)
-        if strings.size == 0
+        if strings.size.zero?
           fail ArgumentError, "Wrong number of Arguments, (2 for 3..n)", caller
         end
 
@@ -55,7 +51,7 @@ module CZMQ
 
         strings = []
         buffers.select {|buffer| buffer != :buffer_out}.each do |buffer|
-          strings << buffer.read_pointer.read_string
+          strings << buffer.read_pointer.get_string(0)
           free(buffer)
         end
         strings

data/lib/czmq/zsys.rb

@@ -16,7 +16,7 @@ module CZMQ
     czmq_function :set_rcvhwm,      :set_rcvhwm,      [:size_t],  :void
     czmq_function :set_pipehwm,     :set_pipehwm,     [:size_t],  :void
     czmq_function :pipehwm,         :pipehwm,         [],         :size_t
-    czmq_function :set_ipv6,        :set_ipv6,        [:int],     :void
+    czmq_function :set_ipv6,        :set_ipv6,        [:bool],    :void
     czmq_function :set_interface,   :set_interface,   [:string],  :void
     czmq_function :set_logident,    :set_logident,    [:string],  :void
     czmq_function :set_logstream,   :set_logstream,   [:pointer], :void
@@ -27,15 +27,16 @@ module CZMQ
     czmq_function :notice,          :notice,          [:string],  :void
     czmq_function :info,            :info,            [:string],  :void
     czmq_function :debug,           :debug,           [:string],  :void
+    czmq_function :has_curve,       :has_curve,       [],         :bool
 
-    attach_variable :interrupted, :zsys_interrupted, :int
-    attach_variable :zctx_interrupted, :zctx_interrupted, :int
+    attach_variable :interrupted, :zsys_interrupted, :bool
+    attach_variable :zctx_interrupted, :zctx_interrupted, :bool
+    attach_variable :allocs, :zsys_allocs, :uint64
 
     handler_set(nil)
-    set_ipv6(1)
 
     at_exit do
-      zctx_interrupted = interrupted = 1
+      zctx_interrupted = interrupted = true
     end
   end
 end

data/lib/czmq.rb

@@ -1,6 +1,7 @@
 require_relative 'czmq/utils'
 require_relative 'czmq/libczmq'
 require_relative 'czmq/zsys'
+require_relative 'czmq/zlogger'
 require_relative 'czmq/zframe'
 require_relative 'czmq/zmsg'
 require_relative 'czmq/zsock'
@@ -12,3 +13,4 @@ require_relative 'czmq/zcertstore'
 require_relative 'czmq/ziflist'
 require_relative 'czmq/zconfig'
 require_relative 'czmq/zstr'
+require_relative 'czmq/zclock'

data/lib/ffi-czmq.rb

@@ -1,6 +1,7 @@
 require_relative 'czmq/utils'
 require_relative 'czmq/libczmq'
 require_relative 'czmq/zsys'
+require_relative 'czmq/zlogger'
 require_relative 'czmq/zframe'
 require_relative 'czmq/zmsg'
 require_relative 'czmq/zsock'
@@ -12,3 +13,4 @@ require_relative 'czmq/zcertstore'
 require_relative 'czmq/ziflist'
 require_relative 'czmq/zconfig'
 require_relative 'czmq/zstr'
+require_relative 'czmq/zclock'

data/lib/libzmq.rb

@@ -0,0 +1,47 @@
+require 'ffi'
+
+module Libzmq
+  extend FFI::Library
+  ffi_lib :libzmq, FFI::Library::LIBC
+
+  POLLIN  = 1
+  POLLOUT = 2
+  POLLERR = 4
+  POLLPRI = 8
+
+  class PollItem < FFI::Struct
+    FD_TYPE = (FFI::Platform.windows? && FFI::Platform::ADDRESS_SIZE == 64) ? :uint64 : :int
+
+    layout  :socket,  :pointer,
+            :fd,      FD_TYPE,
+            :events,  :short,
+            :revents, :short
+
+    def readable?
+      (self[:revents] & POLLIN) > 0
+    end
+
+    def writable?
+      (self[:revents] & POLLOUT) > 0
+    end
+
+    def error?
+      (self[:revents] & POLLERR) > 0
+    end
+  end
+
+  attach_function  :memmove,             [:pointer, :pointer, :size_t],  :pointer
+  attach_function  :poll,    :zmq_poll,  [:pointer, :int, :long],        :int,  blocking: true
+
+  class PollItems < Array
+    def to_ptr
+      items_pointer = FFI::MemoryPointer.new(PollItem, size, true)
+      offset = 0
+      each do |item|
+        Libzmq.memmove(items_pointer + offset, item, item.size)
+        offset += item.size
+      end
+      items_pointer
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-czmq
 version: !ruby/object:Gem::Version
-  version: 0.0.9.pre
+  version: 0.1.1.pre
 platform: ruby
 authors:
 - Hendrik
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-13 00:00:00.000000000 Z
+date: 2014-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -17,28 +17,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.9.5
+        version: 1.9.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.9.5
+        version: 1.9.6
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 3.1.0
 description: czmq ffi wrapper
 email: 
 executables: []
@@ -55,9 +55,11 @@ files:
 - lib/czmq/zactor.rb
 - lib/czmq/zcert.rb
 - lib/czmq/zcertstore.rb
+- lib/czmq/zclock.rb
 - lib/czmq/zconfig.rb
 - lib/czmq/zframe.rb
 - lib/czmq/ziflist.rb
+- lib/czmq/zlogger.rb
 - lib/czmq/zloop.rb
 - lib/czmq/zmsg.rb
 - lib/czmq/zpoller.rb
@@ -65,6 +67,7 @@ files:
 - lib/czmq/zstr.rb
 - lib/czmq/zsys.rb
 - lib/ffi-czmq.rb
+- lib/libzmq.rb
 homepage: https://github.com/Asmod4n/ruby-ffi-czmq
 licenses:
 - Apache-2.0