czmq-ffi-gen 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ea1af55b990ff010a9bc499c1753aec939f9d7a
-  data.tar.gz: b1e54616721dee31e0abf0eba9caa006068bcead
+  metadata.gz: 94b0d8fa86d8c159f8364700f7465871d8dd376a
+  data.tar.gz: bd02800d4543dccb4727a387777d4ff5162d8fa4
 SHA512:
-  metadata.gz: 08d3e268b7019524a98c9e57552a3fd1b415078fbf79d42c66764d4f230a64ab9e90134369cfc85144732e632c0ee517c6d42eb0c95cbb8ce4f92e34c8b18180
-  data.tar.gz: 78619f1f14ca128e033599e3d1642476a5cf28ce3cbdb7ab51a2febbecccc0d0cb7b4cd41f3e53eade4cc7872992b4a17e8e68b757cd4d652f242fbefae79967
+  metadata.gz: 441eda5bb50ceb10c8431c171acfcd0346eaecc75db4a0035c67e5cb6fbb6eb60eb6c77bbb8b088d2722ab2d976c53634d2ceec2b99dd6774abbf6f1a5a9eca4
+  data.tar.gz: a04c994498e5e4a376bad07cb5a1f75656baf45f16819e621ab7ab038080c61e24c71acee288d9594f3e2a9c719ce982f5d9a387bacf368f0e5ba1defe935d82

data/CHANGES.md

@@ -1,3 +1,11 @@
+0.12.0 (11/02/2016)
+-----
+* update CZMQ low-level binding to v4.0.0
+
+0.11.0 (11/02/2016)
+-----
+* update CZMQ low-level binding to v4.0.0-rc1
+
 0.10.0 (09/25/2016)
 -----
 * update CZMQ low-level binding to honor the LIBCZMQ_PATH environment variable

data/lib/czmq-ffi-gen/czmq/ffi.rb

@@ -23,8 +23,8 @@ module CZMQ
     begin
       lib_name = 'libczmq'
       lib_dirs = ['/usr/local/lib', '/opt/local/lib', '/usr/lib64']
-      env_path = ENV["#{lib_name.upcase}_PATH"]
-      lib_dirs = [*env_path.split(':'), *lib_dirs] if env_path
+      env_name = "#{lib_name.upcase}_PATH"
+      lib_dirs = [*ENV[env_name].split(':'), *lib_dirs] if ENV[env_name]
       lib_paths = lib_dirs.map { |path| "#{path}/#{lib_name}.#{::FFI::Platform::LIBSUFFIX}" }
       ffi_lib lib_paths + [lib_name]
       @available = true
@@ -84,8 +84,11 @@ module CZMQ
         attach_function :zcert_unset_meta, [:pointer, :string], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zcert_unset_meta() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zcert_unset_meta()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zcert_unset_meta(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zcert_meta, [:pointer, :string], :string, **opts
@@ -97,7 +100,6 @@ module CZMQ
       attach_function :zcert_dup, [:pointer], :pointer, **opts
       attach_function :zcert_eq, [:pointer, :pointer], :bool, **opts
       attach_function :zcert_print, [:pointer], :void, **opts
-      attach_function :zcert_fprint, [:pointer, :pointer], :void, **opts
       attach_function :zcert_test, [:bool], :void, **opts
 
       require_relative 'ffi/zcert'
@@ -108,8 +110,11 @@ module CZMQ
         attach_function :zcertstore_set_loader, [:pointer, :pointer, :pointer, :pointer], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zcertstore_set_loader() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zcertstore_set_loader()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zcertstore_set_loader(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zcertstore_lookup, [:pointer, :string], :pointer, **opts
@@ -118,12 +123,14 @@ module CZMQ
         attach_function :zcertstore_empty, [:pointer], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zcertstore_empty() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zcertstore_empty()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zcertstore_empty(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zcertstore_print, [:pointer], :void, **opts
-      attach_function :zcertstore_fprint, [:pointer, :pointer], :void, **opts
       attach_function :zcertstore_test, [:bool], :void, **opts
 
       require_relative 'ffi/zcertstore'
@@ -286,32 +293,44 @@ module CZMQ
         attach_function :zframe_routing_id, [:pointer], :uint32, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zframe_routing_id() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zframe_routing_id()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zframe_routing_id(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zframe_set_routing_id, [:pointer, :uint32], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zframe_set_routing_id() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zframe_set_routing_id()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zframe_set_routing_id(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zframe_group, [:pointer], :string, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zframe_group() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zframe_group()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zframe_group(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zframe_set_group, [:pointer, :string], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zframe_set_group() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zframe_set_group()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zframe_set_group(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zframe_eq, [:pointer, :pointer], :bool, **opts
@@ -343,7 +362,6 @@ module CZMQ
       attach_function :zhash_load, [:pointer, :string], :int, **opts
       attach_function :zhash_refresh, [:pointer], :int, **opts
       attach_function :zhash_autofree, [:pointer], :void, **opts
-      attach_function :zhash_foreach, [:pointer, :pointer, :pointer], :int, **opts
       attach_function :zhash_test, [:bool], :void, **opts
 
       require_relative 'ffi/zhash'
@@ -354,8 +372,11 @@ module CZMQ
         attach_function :zhashx_unpack_own, [:pointer, :pointer], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zhashx_unpack_own() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zhashx_unpack_own()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zhashx_unpack_own(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zhashx_destroy, [:pointer], :void, **opts
@@ -381,8 +402,11 @@ module CZMQ
         attach_function :zhashx_pack_own, [:pointer, :pointer], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zhashx_pack_own() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zhashx_pack_own()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zhashx_pack_own(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zhashx_dup, [:pointer], :pointer, **opts
@@ -393,8 +417,6 @@ module CZMQ
       attach_function :zhashx_set_key_comparator, [:pointer, :pointer], :void, **opts
       attach_function :zhashx_set_key_hasher, [:pointer, :pointer], :void, **opts
       attach_function :zhashx_dup_v2, [:pointer], :pointer, **opts
-      attach_function :zhashx_autofree, [:pointer], :void, **opts
-      attach_function :zhashx_foreach, [:pointer, :pointer, :pointer], :int, **opts
       attach_function :zhashx_test, [:bool], :void, **opts
 
       require_relative 'ffi/zhashx'
@@ -485,14 +507,7 @@ module CZMQ
       attach_function :zloop_set_ticket_delay, [:pointer, :size_t], :void, **opts
       attach_function :zloop_set_max_timers, [:pointer, :size_t], :void, **opts
       attach_function :zloop_set_verbose, [:pointer, :bool], :void, **opts
-      begin # DRAFT method
-        attach_function :zloop_set_nonstop, [:pointer, :bool], :void, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zloop_set_nonstop() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
+      attach_function :zloop_set_nonstop, [:pointer, :bool], :void, **opts
       attach_function :zloop_start, [:pointer], :int, **opts
       attach_function :zloop_test, [:bool], :void, **opts
 
@@ -512,16 +527,22 @@ module CZMQ
         attach_function :zmsg_routing_id, [:pointer], :uint32, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zmsg_routing_id() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zmsg_routing_id()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zmsg_routing_id(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zmsg_set_routing_id, [:pointer, :uint32], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zmsg_set_routing_id() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zmsg_set_routing_id()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zmsg_set_routing_id(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zmsg_prepend, [:pointer, :pointer], :int, **opts
@@ -555,14 +576,7 @@ module CZMQ
       attach_function :zpoller_destroy, [:pointer], :void, **opts
       attach_function :zpoller_add, [:pointer, :pointer], :int, **opts
       attach_function :zpoller_remove, [:pointer, :pointer], :int, **opts
-      begin # DRAFT method
-        attach_function :zpoller_set_nonstop, [:pointer, :bool], :void, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zpoller_set_nonstop() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
+      attach_function :zpoller_set_nonstop, [:pointer, :bool], :void, **opts
       attach_function :zpoller_wait, [:pointer, :int], :pointer, **opts
       attach_function :zpoller_expired, [:pointer], :bool, **opts
       attach_function :zpoller_terminated, [:pointer], :bool, **opts
@@ -574,152 +588,209 @@ module CZMQ
         attach_function :zproc_czmq_version, [], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_czmq_version() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_czmq_version()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_czmq_version(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_interrupted, [], :bool, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_interrupted() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_interrupted()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_interrupted(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_has_curve, [], :bool, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_has_curve() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_has_curve()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_has_curve(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_hostname, [], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_hostname() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_hostname()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_hostname(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_daemonize, [:string], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_daemonize() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_daemonize()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_daemonize(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_run_as, [:string, :string, :string], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_run_as() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_run_as()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_run_as(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_set_io_threads, [:size_t], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_set_io_threads() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_set_io_threads()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_set_io_threads(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_set_max_sockets, [:size_t], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_set_max_sockets() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_set_max_sockets()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_set_max_sockets(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_set_biface, [:string], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_set_biface() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_set_biface()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_set_biface(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_biface, [], :string, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_biface() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_biface()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_biface(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_set_log_ident, [:string], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_set_log_ident() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_set_log_ident()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_set_log_ident(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_set_log_sender, [:string], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_set_log_sender() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_set_log_sender()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_set_log_sender(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_set_log_system, [:bool], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_set_log_system() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_set_log_system()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_set_log_system(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_log_error, [:string, :varargs], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_log_error() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_log_error()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_log_error(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_log_warning, [:string, :varargs], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_log_warning() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_log_warning()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_log_warning(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_log_notice, [:string, :varargs], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_log_notice() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_log_notice()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_log_notice(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_log_info, [:string, :varargs], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_log_info() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_log_info()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_log_info(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_log_debug, [:string, :varargs], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_log_debug() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_log_debug()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_log_debug(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zproc_test, [:bool], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zproc_test() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zproc_test()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zproc_test(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
 
@@ -742,48 +813,66 @@ module CZMQ
         attach_function :zsock_new_server, [:string], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_new_server() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_new_server()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_new_server(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zsock_new_client, [:string], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_new_client() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_new_client()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_new_client(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zsock_new_radio, [:string], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_new_radio() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_new_radio()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_new_radio(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zsock_new_dish, [:string], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_new_dish() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_new_dish()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_new_dish(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zsock_new_gather, [:string], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_new_gather() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_new_gather()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_new_gather(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zsock_new_scatter, [:string], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_new_scatter() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_new_scatter()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_new_scatter(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zsock_destroy, [:pointer], :void, **opts
@@ -804,16 +893,22 @@ module CZMQ
         attach_function :zsock_routing_id, [:pointer], :uint32, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_routing_id() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_routing_id()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_routing_id(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zsock_set_routing_id, [:pointer, :uint32], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_set_routing_id() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_set_routing_id()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_set_routing_id(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zsock_set_unbounded, [:pointer], :void, **opts
@@ -824,87 +919,65 @@ module CZMQ
         attach_function :zsock_join, [:pointer, :string], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_join() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_join()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_join(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :zsock_leave, [:pointer, :string], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zsock_leave() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zsock_leave()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zsock_leave(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zsock_is, [:pointer], :bool, **opts
       attach_function :zsock_resolve, [:pointer], :pointer, **opts
-      begin # DRAFT method
-        attach_function :zsock_heartbeat_ivl, [:pointer], :int, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zsock_heartbeat_ivl() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
-      begin # DRAFT method
-        attach_function :zsock_set_heartbeat_ivl, [:pointer, :int], :void, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zsock_set_heartbeat_ivl() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
-      begin # DRAFT method
-        attach_function :zsock_heartbeat_ttl, [:pointer], :int, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zsock_heartbeat_ttl() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
-      begin # DRAFT method
-        attach_function :zsock_set_heartbeat_ttl, [:pointer, :int], :void, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zsock_set_heartbeat_ttl() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
-      begin # DRAFT method
-        attach_function :zsock_heartbeat_timeout, [:pointer], :int, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zsock_heartbeat_timeout() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
-      begin # DRAFT method
-        attach_function :zsock_set_heartbeat_timeout, [:pointer, :int], :void, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zsock_set_heartbeat_timeout() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
-      begin # DRAFT method
-        attach_function :zsock_use_fd, [:pointer], :int, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zsock_use_fd() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
-      begin # DRAFT method
-        attach_function :zsock_set_use_fd, [:pointer, :int], :void, **opts
-      rescue ::FFI::NotFoundError
-        if $VERBOSE || $DEBUG
-          warn "The function zsock_set_use_fd() can't be used through " +
-               "this Ruby binding because it's not available."
-        end
-      end
+      attach_function :zsock_heartbeat_ivl, [:pointer], :int, **opts
+      attach_function :zsock_set_heartbeat_ivl, [:pointer, :int], :void, **opts
+      attach_function :zsock_heartbeat_ttl, [:pointer], :int, **opts
+      attach_function :zsock_set_heartbeat_ttl, [:pointer, :int], :void, **opts
+      attach_function :zsock_heartbeat_timeout, [:pointer], :int, **opts
+      attach_function :zsock_set_heartbeat_timeout, [:pointer, :int], :void, **opts
+      attach_function :zsock_use_fd, [:pointer], :int, **opts
+      attach_function :zsock_set_use_fd, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_xpub_manual, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_xpub_welcome_msg, [:pointer, :string], :void, **opts
+      attach_function :zsock_set_stream_notify, [:pointer, :int], :void, **opts
+      attach_function :zsock_invert_matching, [:pointer], :int, **opts
+      attach_function :zsock_set_invert_matching, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_xpub_verboser, [:pointer, :int], :void, **opts
+      attach_function :zsock_connect_timeout, [:pointer], :int, **opts
+      attach_function :zsock_set_connect_timeout, [:pointer, :int], :void, **opts
+      attach_function :zsock_tcp_maxrt, [:pointer], :int, **opts
+      attach_function :zsock_set_tcp_maxrt, [:pointer, :int], :void, **opts
+      attach_function :zsock_thread_safe, [:pointer], :int, **opts
+      attach_function :zsock_multicast_maxtpdu, [:pointer], :int, **opts
+      attach_function :zsock_set_multicast_maxtpdu, [:pointer, :int], :void, **opts
+      attach_function :zsock_vmci_buffer_size, [:pointer], :int, **opts
+      attach_function :zsock_set_vmci_buffer_size, [:pointer, :int], :void, **opts
+      attach_function :zsock_vmci_buffer_min_size, [:pointer], :int, **opts
+      attach_function :zsock_set_vmci_buffer_min_size, [:pointer, :int], :void, **opts
+      attach_function :zsock_vmci_buffer_max_size, [:pointer], :int, **opts
+      attach_function :zsock_set_vmci_buffer_max_size, [:pointer, :int], :void, **opts
+      attach_function :zsock_vmci_connect_timeout, [:pointer], :int, **opts
+      attach_function :zsock_set_vmci_connect_timeout, [:pointer, :int], :void, **opts
       attach_function :zsock_tos, [:pointer], :int, **opts
       attach_function :zsock_set_tos, [:pointer, :int], :void, **opts
       attach_function :zsock_set_router_handover, [:pointer, :int], :void, **opts
+      attach_function :zsock_set_connect_rid, [:pointer, :string], :void, **opts
+      attach_function :zsock_set_connect_rid_bin, [:pointer, :pointer], :void, **opts
+      attach_function :zsock_handshake_ivl, [:pointer], :int, **opts
+      attach_function :zsock_set_handshake_ivl, [:pointer, :int], :void, **opts
+      attach_function :zsock_socks_proxy, [:pointer], :pointer, **opts
+      attach_function :zsock_set_socks_proxy, [:pointer, :string], :void, **opts
+      attach_function :zsock_set_xpub_nodrop, [:pointer, :int], :void, **opts
       attach_function :zsock_set_router_mandatory, [:pointer, :int], :void, **opts
       attach_function :zsock_set_probe_router, [:pointer, :int], :void, **opts
       attach_function :zsock_set_req_relaxed, [:pointer, :int], :void, **opts
@@ -1011,8 +1084,11 @@ module CZMQ
         attach_function :zstr_str, [:pointer], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function zstr_str() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function zstr_str()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.zstr_str(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       attach_function :zstr_free, [:pointer], :void, **opts
@@ -1024,72 +1100,99 @@ module CZMQ
         attach_function :ztimerset_new, [], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_new() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_new()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_new(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztimerset_destroy, [:pointer], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_destroy() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_destroy()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_destroy(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztimerset_add, [:pointer, :size_t, :pointer, :pointer], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_add() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_add()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_add(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztimerset_cancel, [:pointer, :int], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_cancel() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_cancel()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_cancel(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztimerset_set_interval, [:pointer, :int, :size_t], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_set_interval() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_set_interval()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_set_interval(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztimerset_reset, [:pointer, :int], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_reset() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_reset()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_reset(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztimerset_timeout, [:pointer], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_timeout() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_timeout()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_timeout(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztimerset_execute, [:pointer], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_execute() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_execute()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_execute(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztimerset_test, [:bool], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztimerset_test() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztimerset_test()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztimerset_test(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
 
@@ -1099,88 +1202,121 @@ module CZMQ
         attach_function :ztrie_new, [:pointer], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_new() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_new()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_new(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_destroy, [:pointer], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_destroy() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_destroy()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_destroy(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_insert_route, [:pointer, :string, :pointer, :pointer], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_insert_route() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_insert_route()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_insert_route(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_remove_route, [:pointer, :string], :int, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_remove_route() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_remove_route()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_remove_route(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_matches, [:pointer, :string], :bool, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_matches() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_matches()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_matches(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_hit_data, [:pointer], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_hit_data() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_hit_data()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_hit_data(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_hit_parameter_count, [:pointer], :size_t, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_hit_parameter_count() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_hit_parameter_count()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_hit_parameter_count(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_hit_parameters, [:pointer], :pointer, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_hit_parameters() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_hit_parameters()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_hit_parameters(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_hit_asterisk_match, [:pointer], :string, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_hit_asterisk_match() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_hit_asterisk_match()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_hit_asterisk_match(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_print, [:pointer], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_print() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_print()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_print(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end
       begin # DRAFT method
         attach_function :ztrie_test, [:bool], :void, **opts
       rescue ::FFI::NotFoundError
         if $VERBOSE || $DEBUG
-          warn "The function ztrie_test() can't be used through " +
-               "this Ruby binding because it's not available."
+          warn "The DRAFT function ztrie_test()" +
+            " is not provided by the installed CZMQ library."
+        end
+        def self.ztrie_test(*)
+          raise NotImplementedError, "compile CZMQ with --enable-drafts"
         end
       end