czmq-ffi-gen 0.14.0 → 1.0.0

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

@@ -95,7 +95,8 @@ module CZMQ
       end
 
       # Add a reader to be polled. Returns 0 if OK, -1 on failure. The reader may
-      # be a libzmq void * socket, a zsock_t instance, or a zactor_t instance.
+      # be a libzmq void * socket, a zsock_t instance, a zactor_t instance or a
+      # file handle.
       #
       # @param reader [::FFI::Pointer, #to_ptr]
       # @return [Integer]
@@ -134,14 +135,15 @@ module CZMQ
       end
 
       # Poll the registered readers for I/O, return first reader that has input.
-      # The reader will be a libzmq void * socket, or a zsock_t or zactor_t
-      # instance as specified in zpoller_new/zpoller_add. The timeout should be
-      # zero or greater, or -1 to wait indefinitely. Socket priority is defined
-      # by their order in the poll list. If you need a balanced poll, use the low
-      # level zmq_poll method directly. If the poll call was interrupted (SIGINT),
-      # or the ZMQ context was destroyed, or the timeout expired, returns NULL.
-      # You can test the actual exit condition by calling zpoller_expired () and
-      # zpoller_terminated (). The timeout is in msec.
+      # The reader will be a libzmq void * socket, a zsock_t, a zactor_t
+      # instance or a file handle as specified in zpoller_new/zpoller_add. The
+      # timeout should be zero or greater, or -1 to wait indefinitely. Socket
+      # priority is defined by their order in the poll list. If you need a
+      # balanced poll, use the low level zmq_poll method directly. If the poll
+      # call was interrupted (SIGINT), or the ZMQ context was destroyed, or the
+      # timeout expired, returns NULL. You can test the actual exit condition by
+      # calling zpoller_expired () and zpoller_terminated (). The timeout is in
+      # msec.
       #
       # @param timeout [Integer, #to_int, #to_i]
       # @return [::FFI::Pointer]

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

@@ -92,28 +92,53 @@ module CZMQ
         result
       end
 
+      # Return command line arguments (the first item is the executable) or
+      # NULL if not set.
+      #
+      # @return [Zlist]
+      def args()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zproc_args(self_p)
+        result = Zlist.__new result, true
+        result
+      end
+
       # Setup the command line arguments, the first item must be an (absolute) filename
       # to run.
       #
-      # @param args [Zlistx, #__ptr]
+      # @param arguments [#__ptr_give_ref]
+      # @return [void]
+      def set_args(arguments)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        arguments = arguments.__ptr_give_ref
+        result = ::CZMQ::FFI.zproc_set_args(self_p, arguments)
+        result
+      end
+
+      # Setup the command line arguments, the first item must be an (absolute) filename
+      # to run. Variadic function, must be NULL terminated.
+      #
+      # @param arguments [String, #to_s, nil]
+      # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
       # @return [void]
-      def set_args(args)
+      def set_argsx(arguments, *args)
         raise DestroyedError unless @ptr
         self_p = @ptr
-        args = args.__ptr if args
-        result = ::CZMQ::FFI.zproc_set_args(self_p, args)
+        result = ::CZMQ::FFI.zproc_set_argsx(self_p, arguments, *args)
         result
       end
 
       # Setup the environment variables for the process.
       #
-      # @param args [Zhashx, #__ptr]
+      # @param arguments [#__ptr_give_ref]
       # @return [void]
-      def set_env(args)
+      def set_env(arguments)
         raise DestroyedError unless @ptr
         self_p = @ptr
-        args = args.__ptr if args
-        result = ::CZMQ::FFI.zproc_set_env(self_p, args)
+        arguments = arguments.__ptr_give_ref
+        result = ::CZMQ::FFI.zproc_set_env(self_p, arguments)
         result
       end
 
@@ -189,7 +214,7 @@ module CZMQ
         result
       end
 
-      # Starts the process.
+      # Starts the process, return just before execve/CreateProcess.
       #
       # @return [Integer]
       def run()
@@ -229,19 +254,33 @@ module CZMQ
         result
       end
 
+      # The timeout should be zero or greater, or -1 to wait indefinitely.
       # wait or poll process status, return return code
       #
-      # @param hang [Boolean]
+      # @param timeout [Integer, #to_int, #to_i]
       # @return [Integer]
-      def wait(hang)
+      def wait(timeout)
         raise DestroyedError unless @ptr
         self_p = @ptr
-        hang = !(0==hang||!hang) # boolean
-        result = ::CZMQ::FFI.zproc_wait(self_p, hang)
+        timeout = Integer(timeout)
+        result = ::CZMQ::FFI.zproc_wait(self_p, timeout)
         result
       end
 
-      # return internal actor, usefull for the polling if process died
+      # send SIGTERM signal to the subprocess, wait for grace period and
+      # eventually send SIGKILL
+      #
+      # @param timeout [Integer, #to_int, #to_i]
+      # @return [void]
+      def shutdown(timeout)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        timeout = Integer(timeout)
+        result = ::CZMQ::FFI.zproc_shutdown(self_p, timeout)
+        result
+      end
+
+      # return internal actor, useful for the polling if process died
       #
       # @return [::FFI::Pointer]
       def actor()
@@ -275,209 +314,6 @@ module CZMQ
         result
       end
 
-      # Returns CZMQ version as a single 6-digit integer encoding the major
-      # version (x 10000), the minor version (x 100) and the patch.
-      #
-      # @return [Integer]
-      def self.czmq_version()
-        result = ::CZMQ::FFI.zproc_czmq_version()
-        result
-      end
-
-      # Returns true if the process received a SIGINT or SIGTERM signal.
-      # It is good practice to use this method to exit any infinite loop
-      # processing messages.
-      #
-      # @return [Boolean]
-      def self.interrupted()
-        result = ::CZMQ::FFI.zproc_interrupted()
-        result
-      end
-
-      # Returns true if the underlying libzmq supports CURVE security.
-      #
-      # @return [Boolean]
-      def self.has_curve()
-        result = ::CZMQ::FFI.zproc_has_curve()
-        result
-      end
-
-      # Return current host name, for use in public tcp:// endpoints.
-      # If the host name is not resolvable, returns NULL.
-      #
-      # @return [::FFI::AutoPointer]
-      def self.hostname()
-        result = ::CZMQ::FFI.zproc_hostname()
-        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
-        result
-      end
-
-      # Move the current process into the background. The precise effect
-      # depends on the operating system. On POSIX boxes, moves to a specified
-      # working directory (if specified), closes all file handles, reopens
-      # stdin, stdout, and stderr to the null device, and sets the process to
-      # ignore SIGHUP. On Windows, does nothing. Returns 0 if OK, -1 if there
-      # was an error.
-      #
-      # @param workdir [String, #to_s, nil]
-      # @return [void]
-      def self.daemonize(workdir)
-        result = ::CZMQ::FFI.zproc_daemonize(workdir)
-        result
-      end
-
-      # Drop the process ID into the lockfile, with exclusive lock, and
-      # switch the process to the specified group and/or user. Any of the
-      # arguments may be null, indicating a no-op. Returns 0 on success,
-      # -1 on failure. Note if you combine this with zsys_daemonize, run
-      # after, not before that method, or the lockfile will hold the wrong
-      # process ID.
-      #
-      # @param lockfile [String, #to_s, nil]
-      # @param group [String, #to_s, nil]
-      # @param user [String, #to_s, nil]
-      # @return [void]
-      def self.run_as(lockfile, group, user)
-        result = ::CZMQ::FFI.zproc_run_as(lockfile, group, user)
-        result
-      end
-
-      # Configure the number of I/O threads that ZeroMQ will use. A good
-      # rule of thumb is one thread per gigabit of traffic in or out. The
-      # default is 1, sufficient for most applications. If the environment
-      # variable ZSYS_IO_THREADS is defined, that provides the default.
-      # Note that this method is valid only before any socket is created.
-      #
-      # @param io_threads [Integer, #to_int, #to_i]
-      # @return [void]
-      def self.set_io_threads(io_threads)
-        io_threads = Integer(io_threads)
-        result = ::CZMQ::FFI.zproc_set_io_threads(io_threads)
-        result
-      end
-
-      # Configure the number of sockets that ZeroMQ will allow. The default
-      # is 1024. The actual limit depends on the system, and you can query it
-      # by using zsys_socket_limit (). A value of zero means "maximum".
-      # Note that this method is valid only before any socket is created.
-      #
-      # @param max_sockets [Integer, #to_int, #to_i]
-      # @return [void]
-      def self.set_max_sockets(max_sockets)
-        max_sockets = Integer(max_sockets)
-        result = ::CZMQ::FFI.zproc_set_max_sockets(max_sockets)
-        result
-      end
-
-      # Set network interface name to use for broadcasts, particularly zbeacon.
-      # This lets the interface be configured for test environments where required.
-      # For example, on Mac OS X, zbeacon cannot bind to 255.255.255.255 which is
-      # the default when there is no specified interface. If the environment
-      # variable ZSYS_INTERFACE is set, use that as the default interface name.
-      # Setting the interface to "*" means "use all available interfaces".
-      #
-      # @param value [String, #to_s, nil]
-      # @return [void]
-      def self.set_biface(value)
-        result = ::CZMQ::FFI.zproc_set_biface(value)
-        result
-      end
-
-      # Return network interface to use for broadcasts, or "" if none was set.
-      #
-      # @return [String]
-      def self.biface()
-        result = ::CZMQ::FFI.zproc_biface()
-        result
-      end
-
-      # Set log identity, which is a string that prefixes all log messages sent
-      # by this process. The log identity defaults to the environment variable
-      # ZSYS_LOGIDENT, if that is set.
-      #
-      # @param value [String, #to_s, nil]
-      # @return [void]
-      def self.set_log_ident(value)
-        result = ::CZMQ::FFI.zproc_set_log_ident(value)
-        result
-      end
-
-      # Sends log output to a PUB socket bound to the specified endpoint. To
-      # collect such log output, create a SUB socket, subscribe to the traffic
-      # you care about, and connect to the endpoint. Log traffic is sent as a
-      # single string frame, in the same format as when sent to stdout. The
-      # log system supports a single sender; multiple calls to this method will
-      # bind the same sender to multiple endpoints. To disable the sender, call
-      # this method with a null argument.
-      #
-      # @param endpoint [String, #to_s, nil]
-      # @return [void]
-      def self.set_log_sender(endpoint)
-        result = ::CZMQ::FFI.zproc_set_log_sender(endpoint)
-        result
-      end
-
-      # Enable or disable logging to the system facility (syslog on POSIX boxes,
-      # event log on Windows). By default this is disabled.
-      #
-      # @param logsystem [Boolean]
-      # @return [void]
-      def self.set_log_system(logsystem)
-        logsystem = !(0==logsystem||!logsystem) # boolean
-        result = ::CZMQ::FFI.zproc_set_log_system(logsystem)
-        result
-      end
-
-      # Log error condition - highest priority
-      #
-      # @param format [String, #to_s, nil]
-      # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
-      # @return [void]
-      def self.log_error(format, *args)
-        result = ::CZMQ::FFI.zproc_log_error(format, *args)
-        result
-      end
-
-      # Log warning condition - high priority
-      #
-      # @param format [String, #to_s, nil]
-      # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
-      # @return [void]
-      def self.log_warning(format, *args)
-        result = ::CZMQ::FFI.zproc_log_warning(format, *args)
-        result
-      end
-
-      # Log normal, but significant, condition - normal priority
-      #
-      # @param format [String, #to_s, nil]
-      # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
-      # @return [void]
-      def self.log_notice(format, *args)
-        result = ::CZMQ::FFI.zproc_log_notice(format, *args)
-        result
-      end
-
-      # Log informational message - low priority
-      #
-      # @param format [String, #to_s, nil]
-      # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
-      # @return [void]
-      def self.log_info(format, *args)
-        result = ::CZMQ::FFI.zproc_log_info(format, *args)
-        result
-      end
-
-      # Log debug-level message - lowest priority
-      #
-      # @param format [String, #to_s, nil]
-      # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
-      # @return [void]
-      def self.log_debug(format, *args)
-        result = ::CZMQ::FFI.zproc_log_debug(format, *args)
-        result
-      end
-
       # Self test of this class.
       #
       # @param verbose [Boolean]

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

@@ -233,6 +233,22 @@ module CZMQ
         __new ptr
       end
 
+      # Create a DGRAM (UDP) socket. Default action is bind.
+      # The endpoint is a string consisting of a
+      # 'transport'`://` followed by an 'address'. As this is
+      # a UDP socket the 'transport' has to be 'udp'. The
+      # 'address' specifies the ip address and port to
+      # bind to. For example:  udp://127.0.0.1:1234
+      # Note: To send to an endpoint over UDP you have to
+      # send a message with the destination endpoint address
+      # as a first message!
+      # @param endpoint [String, #to_s, nil]
+      # @return [CZMQ::Zsock]
+      def self.new_dgram(endpoint)
+        ptr = ::CZMQ::FFI.zsock_new_dgram(endpoint)
+        __new ptr
+      end
+
       # Destroy the socket. You must use this for any socket created via the
       # zsock_new method.
       #
@@ -369,6 +385,7 @@ module CZMQ
       #     c = zchunk_t *
       #     f = zframe_t *
       #     h = zhashx_t *
+      #     l = zlistx_t * (DRAFT)
       #     U = zuuid_t *
       #     p = void * (sends the pointer value, only meaningful over inproc)
       #     m = zmsg_t * (sends all frames in the zmsg)
@@ -406,6 +423,7 @@ module CZMQ
       #     c = zchunk_t *
       #     f = zframe_t *
       #     h = zhashx_t *
+      #     l = zlistx_t * (DRAFT)
       #     U = zuuid_t *
       #     p = void * (sends the pointer value, only meaningful over inproc)
       #     m = zmsg_t * (sends all frames in the zmsg)
@@ -475,8 +493,9 @@ module CZMQ
       #     f = zframe_t ** (creates zframe)
       #     U = zuuid_t * (creates a zuuid with the data)
       #     h = zhashx_t ** (creates zhashx)
+      #     l = zlistx_t ** (creates zlistx) (DRAFT)
       #     p = void ** (stores pointer)
-      #     m = zmsg_t ** (creates a zmsg with the remaing frames)
+      #     m = zmsg_t ** (creates a zmsg with the remaining frames)
       #     z = null, asserts empty frame (0 arguments)
       #     u = uint * (stores unsigned integer, deprecated)
       #
@@ -512,8 +531,9 @@ module CZMQ
       #     f = zframe_t ** (creates zframe)
       #     U = zuuid_t * (creates a zuuid with the data)
       #     h = zhashx_t ** (creates zhashx)
+      #     l = zlistx_t ** (creates zlistx) (DRAFT)
       #     p = void ** (stores pointer)
-      #     m = zmsg_t ** (creates a zmsg with the remaing frames)
+      #     m = zmsg_t ** (creates a zmsg with the remaining frames)
       #     z = null, asserts empty frame (0 arguments)
       #     u = uint * (stores unsigned integer, deprecated)
       #
@@ -914,6 +934,930 @@ module CZMQ
         result
       end
 
+      # Check whether the socket has available message to read.
+      #
+      # @return [Boolean]
+      def has_in()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_has_in(self_p)
+        result
+      end
+
+      # Check whether the socket has available message to read.
+      #
+      # This is the polymorphic version of #has_in.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Boolean]
+      def self.has_in(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_has_in(self_p)
+        result
+      end
+
+      # Set socket option `only_first_subscribe`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param only_first_subscribe [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_only_first_subscribe(only_first_subscribe)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        only_first_subscribe = Integer(only_first_subscribe)
+        result = ::CZMQ::FFI.zsock_set_only_first_subscribe(self_p, only_first_subscribe)
+        result
+      end
+
+      # Set socket option `only_first_subscribe`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_only_first_subscribe.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param only_first_subscribe [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_only_first_subscribe(self_p, only_first_subscribe)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        only_first_subscribe = Integer(only_first_subscribe)
+        result = ::CZMQ::FFI.zsock_set_only_first_subscribe(self_p, only_first_subscribe)
+        result
+      end
+
+      # Set socket option `hello_msg`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param hello_msg [Zframe, #__ptr]
+      # @return [void]
+      def set_hello_msg(hello_msg)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        hello_msg = hello_msg.__ptr if hello_msg
+        result = ::CZMQ::FFI.zsock_set_hello_msg(self_p, hello_msg)
+        result
+      end
+
+      # Set socket option `hello_msg`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_hello_msg.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param hello_msg [Zframe, #__ptr]
+      # @return [void]
+      def self.set_hello_msg(self_p, hello_msg)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        hello_msg = hello_msg.__ptr if hello_msg
+        result = ::CZMQ::FFI.zsock_set_hello_msg(self_p, hello_msg)
+        result
+      end
+
+      # Set socket option `disconnect_msg`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param disconnect_msg [Zframe, #__ptr]
+      # @return [void]
+      def set_disconnect_msg(disconnect_msg)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        disconnect_msg = disconnect_msg.__ptr if disconnect_msg
+        result = ::CZMQ::FFI.zsock_set_disconnect_msg(self_p, disconnect_msg)
+        result
+      end
+
+      # Set socket option `disconnect_msg`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_disconnect_msg.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param disconnect_msg [Zframe, #__ptr]
+      # @return [void]
+      def self.set_disconnect_msg(self_p, disconnect_msg)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        disconnect_msg = disconnect_msg.__ptr if disconnect_msg
+        result = ::CZMQ::FFI.zsock_set_disconnect_msg(self_p, disconnect_msg)
+        result
+      end
+
+      # Set socket option `wss_trust_system`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param wss_trust_system [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_wss_trust_system(wss_trust_system)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        wss_trust_system = Integer(wss_trust_system)
+        result = ::CZMQ::FFI.zsock_set_wss_trust_system(self_p, wss_trust_system)
+        result
+      end
+
+      # Set socket option `wss_trust_system`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_wss_trust_system.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param wss_trust_system [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_wss_trust_system(self_p, wss_trust_system)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        wss_trust_system = Integer(wss_trust_system)
+        result = ::CZMQ::FFI.zsock_set_wss_trust_system(self_p, wss_trust_system)
+        result
+      end
+
+      # Set socket option `wss_hostname`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param wss_hostname [String, #to_s, nil]
+      # @return [void]
+      def set_wss_hostname(wss_hostname)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_set_wss_hostname(self_p, wss_hostname)
+        result
+      end
+
+      # Set socket option `wss_hostname`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_wss_hostname.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param wss_hostname [String, #to_s, nil]
+      # @return [void]
+      def self.set_wss_hostname(self_p, wss_hostname)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_set_wss_hostname(self_p, wss_hostname)
+        result
+      end
+
+      # Set socket option `wss_trust_pem`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param wss_trust_pem [String, #to_s, nil]
+      # @return [void]
+      def set_wss_trust_pem(wss_trust_pem)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_set_wss_trust_pem(self_p, wss_trust_pem)
+        result
+      end
+
+      # Set socket option `wss_trust_pem`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_wss_trust_pem.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param wss_trust_pem [String, #to_s, nil]
+      # @return [void]
+      def self.set_wss_trust_pem(self_p, wss_trust_pem)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_set_wss_trust_pem(self_p, wss_trust_pem)
+        result
+      end
+
+      # Set socket option `wss_cert_pem`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param wss_cert_pem [String, #to_s, nil]
+      # @return [void]
+      def set_wss_cert_pem(wss_cert_pem)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_set_wss_cert_pem(self_p, wss_cert_pem)
+        result
+      end
+
+      # Set socket option `wss_cert_pem`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_wss_cert_pem.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param wss_cert_pem [String, #to_s, nil]
+      # @return [void]
+      def self.set_wss_cert_pem(self_p, wss_cert_pem)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_set_wss_cert_pem(self_p, wss_cert_pem)
+        result
+      end
+
+      # Set socket option `wss_key_pem`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param wss_key_pem [String, #to_s, nil]
+      # @return [void]
+      def set_wss_key_pem(wss_key_pem)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_set_wss_key_pem(self_p, wss_key_pem)
+        result
+      end
+
+      # Set socket option `wss_key_pem`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_wss_key_pem.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param wss_key_pem [String, #to_s, nil]
+      # @return [void]
+      def self.set_wss_key_pem(self_p, wss_key_pem)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_set_wss_key_pem(self_p, wss_key_pem)
+        result
+      end
+
+      # Get socket option `out_batch_size`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [Integer]
+      def out_batch_size()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_out_batch_size(self_p)
+        result
+      end
+
+      # Get socket option `out_batch_size`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #out_batch_size.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Integer]
+      def self.out_batch_size(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_out_batch_size(self_p)
+        result
+      end
+
+      # Set socket option `out_batch_size`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param out_batch_size [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_out_batch_size(out_batch_size)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        out_batch_size = Integer(out_batch_size)
+        result = ::CZMQ::FFI.zsock_set_out_batch_size(self_p, out_batch_size)
+        result
+      end
+
+      # Set socket option `out_batch_size`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_out_batch_size.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param out_batch_size [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_out_batch_size(self_p, out_batch_size)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        out_batch_size = Integer(out_batch_size)
+        result = ::CZMQ::FFI.zsock_set_out_batch_size(self_p, out_batch_size)
+        result
+      end
+
+      # Get socket option `in_batch_size`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [Integer]
+      def in_batch_size()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_in_batch_size(self_p)
+        result
+      end
+
+      # Get socket option `in_batch_size`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #in_batch_size.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Integer]
+      def self.in_batch_size(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_in_batch_size(self_p)
+        result
+      end
+
+      # Set socket option `in_batch_size`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param in_batch_size [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_in_batch_size(in_batch_size)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        in_batch_size = Integer(in_batch_size)
+        result = ::CZMQ::FFI.zsock_set_in_batch_size(self_p, in_batch_size)
+        result
+      end
+
+      # Set socket option `in_batch_size`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_in_batch_size.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param in_batch_size [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_in_batch_size(self_p, in_batch_size)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        in_batch_size = Integer(in_batch_size)
+        result = ::CZMQ::FFI.zsock_set_in_batch_size(self_p, in_batch_size)
+        result
+      end
+
+      # Get socket option `socks_password`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [::FFI::AutoPointer]
+      def socks_password()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_socks_password(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Get socket option `socks_password`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #socks_password.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [::FFI::AutoPointer]
+      def self.socks_password(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_socks_password(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Set socket option `socks_password`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param socks_password [String, #to_s, nil]
+      # @return [void]
+      def set_socks_password(socks_password)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_set_socks_password(self_p, socks_password)
+        result
+      end
+
+      # Set socket option `socks_password`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_socks_password.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param socks_password [String, #to_s, nil]
+      # @return [void]
+      def self.set_socks_password(self_p, socks_password)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_set_socks_password(self_p, socks_password)
+        result
+      end
+
+      # Get socket option `socks_username`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [::FFI::AutoPointer]
+      def socks_username()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_socks_username(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Get socket option `socks_username`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #socks_username.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [::FFI::AutoPointer]
+      def self.socks_username(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_socks_username(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Set socket option `socks_username`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param socks_username [String, #to_s, nil]
+      # @return [void]
+      def set_socks_username(socks_username)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_set_socks_username(self_p, socks_username)
+        result
+      end
+
+      # Set socket option `socks_username`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_socks_username.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param socks_username [String, #to_s, nil]
+      # @return [void]
+      def self.set_socks_username(self_p, socks_username)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_set_socks_username(self_p, socks_username)
+        result
+      end
+
+      # Set socket option `xpub_manual_last_value`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param xpub_manual_last_value [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_xpub_manual_last_value(xpub_manual_last_value)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        xpub_manual_last_value = Integer(xpub_manual_last_value)
+        result = ::CZMQ::FFI.zsock_set_xpub_manual_last_value(self_p, xpub_manual_last_value)
+        result
+      end
+
+      # Set socket option `xpub_manual_last_value`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_xpub_manual_last_value.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param xpub_manual_last_value [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_xpub_manual_last_value(self_p, xpub_manual_last_value)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        xpub_manual_last_value = Integer(xpub_manual_last_value)
+        result = ::CZMQ::FFI.zsock_set_xpub_manual_last_value(self_p, xpub_manual_last_value)
+        result
+      end
+
+      # Get socket option `router_notify`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [Integer]
+      def router_notify()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_router_notify(self_p)
+        result
+      end
+
+      # Get socket option `router_notify`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #router_notify.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Integer]
+      def self.router_notify(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_router_notify(self_p)
+        result
+      end
+
+      # Set socket option `router_notify`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param router_notify [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_router_notify(router_notify)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        router_notify = Integer(router_notify)
+        result = ::CZMQ::FFI.zsock_set_router_notify(self_p, router_notify)
+        result
+      end
+
+      # Set socket option `router_notify`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_router_notify.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param router_notify [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_router_notify(self_p, router_notify)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        router_notify = Integer(router_notify)
+        result = ::CZMQ::FFI.zsock_set_router_notify(self_p, router_notify)
+        result
+      end
+
+      # Get socket option `multicast_loop`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [Integer]
+      def multicast_loop()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_multicast_loop(self_p)
+        result
+      end
+
+      # Get socket option `multicast_loop`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #multicast_loop.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Integer]
+      def self.multicast_loop(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_multicast_loop(self_p)
+        result
+      end
+
+      # Set socket option `multicast_loop`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param multicast_loop [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_multicast_loop(multicast_loop)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        multicast_loop = Integer(multicast_loop)
+        result = ::CZMQ::FFI.zsock_set_multicast_loop(self_p, multicast_loop)
+        result
+      end
+
+      # Set socket option `multicast_loop`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_multicast_loop.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param multicast_loop [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_multicast_loop(self_p, multicast_loop)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        multicast_loop = Integer(multicast_loop)
+        result = ::CZMQ::FFI.zsock_set_multicast_loop(self_p, multicast_loop)
+        result
+      end
+
+      # Get socket option `metadata`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [::FFI::AutoPointer]
+      def metadata()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_metadata(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Get socket option `metadata`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #metadata.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [::FFI::AutoPointer]
+      def self.metadata(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_metadata(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Set socket option `metadata`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param metadata [String, #to_s, nil]
+      # @return [void]
+      def set_metadata(metadata)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_set_metadata(self_p, metadata)
+        result
+      end
+
+      # Set socket option `metadata`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_metadata.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param metadata [String, #to_s, nil]
+      # @return [void]
+      def self.set_metadata(self_p, metadata)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_set_metadata(self_p, metadata)
+        result
+      end
+
+      # Get socket option `loopback_fastpath`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [Integer]
+      def loopback_fastpath()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_loopback_fastpath(self_p)
+        result
+      end
+
+      # Get socket option `loopback_fastpath`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #loopback_fastpath.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Integer]
+      def self.loopback_fastpath(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_loopback_fastpath(self_p)
+        result
+      end
+
+      # Set socket option `loopback_fastpath`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param loopback_fastpath [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_loopback_fastpath(loopback_fastpath)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        loopback_fastpath = Integer(loopback_fastpath)
+        result = ::CZMQ::FFI.zsock_set_loopback_fastpath(self_p, loopback_fastpath)
+        result
+      end
+
+      # Set socket option `loopback_fastpath`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_loopback_fastpath.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param loopback_fastpath [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_loopback_fastpath(self_p, loopback_fastpath)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        loopback_fastpath = Integer(loopback_fastpath)
+        result = ::CZMQ::FFI.zsock_set_loopback_fastpath(self_p, loopback_fastpath)
+        result
+      end
+
+      # Get socket option `zap_enforce_domain`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [Integer]
+      def zap_enforce_domain()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_zap_enforce_domain(self_p)
+        result
+      end
+
+      # Get socket option `zap_enforce_domain`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #zap_enforce_domain.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Integer]
+      def self.zap_enforce_domain(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_zap_enforce_domain(self_p)
+        result
+      end
+
+      # Set socket option `zap_enforce_domain`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param zap_enforce_domain [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_zap_enforce_domain(zap_enforce_domain)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        zap_enforce_domain = Integer(zap_enforce_domain)
+        result = ::CZMQ::FFI.zsock_set_zap_enforce_domain(self_p, zap_enforce_domain)
+        result
+      end
+
+      # Set socket option `zap_enforce_domain`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_zap_enforce_domain.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param zap_enforce_domain [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_zap_enforce_domain(self_p, zap_enforce_domain)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        zap_enforce_domain = Integer(zap_enforce_domain)
+        result = ::CZMQ::FFI.zsock_set_zap_enforce_domain(self_p, zap_enforce_domain)
+        result
+      end
+
+      # Get socket option `gssapi_principal_nametype`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [Integer]
+      def gssapi_principal_nametype()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_gssapi_principal_nametype(self_p)
+        result
+      end
+
+      # Get socket option `gssapi_principal_nametype`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #gssapi_principal_nametype.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Integer]
+      def self.gssapi_principal_nametype(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_gssapi_principal_nametype(self_p)
+        result
+      end
+
+      # Set socket option `gssapi_principal_nametype`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param gssapi_principal_nametype [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_gssapi_principal_nametype(gssapi_principal_nametype)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        gssapi_principal_nametype = Integer(gssapi_principal_nametype)
+        result = ::CZMQ::FFI.zsock_set_gssapi_principal_nametype(self_p, gssapi_principal_nametype)
+        result
+      end
+
+      # Set socket option `gssapi_principal_nametype`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_gssapi_principal_nametype.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param gssapi_principal_nametype [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_gssapi_principal_nametype(self_p, gssapi_principal_nametype)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        gssapi_principal_nametype = Integer(gssapi_principal_nametype)
+        result = ::CZMQ::FFI.zsock_set_gssapi_principal_nametype(self_p, gssapi_principal_nametype)
+        result
+      end
+
+      # Get socket option `gssapi_service_principal_nametype`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [Integer]
+      def gssapi_service_principal_nametype()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_gssapi_service_principal_nametype(self_p)
+        result
+      end
+
+      # Get socket option `gssapi_service_principal_nametype`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #gssapi_service_principal_nametype.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [Integer]
+      def self.gssapi_service_principal_nametype(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_gssapi_service_principal_nametype(self_p)
+        result
+      end
+
+      # Set socket option `gssapi_service_principal_nametype`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param gssapi_service_principal_nametype [Integer, #to_int, #to_i]
+      # @return [void]
+      def set_gssapi_service_principal_nametype(gssapi_service_principal_nametype)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        gssapi_service_principal_nametype = Integer(gssapi_service_principal_nametype)
+        result = ::CZMQ::FFI.zsock_set_gssapi_service_principal_nametype(self_p, gssapi_service_principal_nametype)
+        result
+      end
+
+      # Set socket option `gssapi_service_principal_nametype`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_gssapi_service_principal_nametype.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param gssapi_service_principal_nametype [Integer, #to_int, #to_i]
+      # @return [void]
+      def self.set_gssapi_service_principal_nametype(self_p, gssapi_service_principal_nametype)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        gssapi_service_principal_nametype = Integer(gssapi_service_principal_nametype)
+        result = ::CZMQ::FFI.zsock_set_gssapi_service_principal_nametype(self_p, gssapi_service_principal_nametype)
+        result
+      end
+
+      # Get socket option `bindtodevice`.
+      # Available from libzmq 4.3.0.
+      #
+      # @return [::FFI::AutoPointer]
+      def bindtodevice()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_bindtodevice(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Get socket option `bindtodevice`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #bindtodevice.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @return [::FFI::AutoPointer]
+      def self.bindtodevice(self_p)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_bindtodevice(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Set socket option `bindtodevice`.
+      # Available from libzmq 4.3.0.
+      #
+      # @param bindtodevice [String, #to_s, nil]
+      # @return [void]
+      def set_bindtodevice(bindtodevice)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zsock_set_bindtodevice(self_p, bindtodevice)
+        result
+      end
+
+      # Set socket option `bindtodevice`.
+      # Available from libzmq 4.3.0.
+      #
+      # This is the polymorphic version of #set_bindtodevice.
+      #
+      # @param self_p [CZMQ::Zsock, #__ptr, ::FFI::Pointer, nil]
+      #   object reference to use this method on
+      # @param bindtodevice [String, #to_s, nil]
+      # @return [void]
+      def self.set_bindtodevice(self_p, bindtodevice)
+        self_p = self_p.__ptr if self_p.respond_to?(:__ptr)
+        result = ::CZMQ::FFI.zsock_set_bindtodevice(self_p, bindtodevice)
+        result
+      end
+
       # Get socket option `heartbeat_ivl`.
       # Available from libzmq 4.2.0.
       #