czmq-ffi-gen 0.14.0 → 1.0.0

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

@@ -5,7 +5,7 @@
 
 module CZMQ
   module FFI
-    VERSION = '4.0.3'
+    VERSION = '4.2.1'
   end
 end
 

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

@@ -95,8 +95,8 @@ module CZMQ
       #
       # An example - to send $KTHXBAI string
       #
-      #     if (zstr_send (self->pipe, "$KTHXBAI") == 0)
-      #         zsock_wait (self->pipe);
+      #     if (zstr_send (self, "$KTHXBAI") == 0)
+      #         zsock_wait (self);
       #     typedef void (zactor_destructor_fn) (
       #         zactor_t *self);
       #

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

@@ -9,14 +9,17 @@ module CZMQ
     # Platform independent command line argument parsing helpers
     #
     # There are two kind of elements provided by this class
-    # foo --named-parameter --parameter with_value positional arguments -a gain-parameter
-    # zargs keeps poision only for arguments, parameters are to be accessed like hash.
+    # Named parameters, accessed by param_get and param_has methods
+    #   * --named-parameter
+    #   * --parameter with_value
+    #   * -a val
+    # Positional arguments, accessed by zargs_first, zargs_next
     #
     # It DOES:
     # * provide easy to use CLASS compatible API for accessing argv
     # * is platform independent
     # * provide getopt_long style -- argument, which delimits parameters from arguments
-    # * makes parameters positon independent
+    # * makes parameters position independent
     #
     # It does NOT
     # * change argv
@@ -173,8 +176,7 @@ module CZMQ
         result
       end
 
-      # Return current parameter name, or NULL if there are no named
-      # parameters.
+      # Return current parameter name, or NULL if there are no named parameters.
       #
       # @return [String]
       def param_name()
@@ -184,49 +186,49 @@ module CZMQ
         result
       end
 
-      # Return value of named parameter, NULL if no given parameter has
-      # been specified, or special value for wich zargs_param_empty ()
-      # returns true.
+      # Return value of named parameter or NULL is it has no value (or was not specified)
       #
-      # @param keys [String, #to_s, nil]
+      # @param name [String, #to_s, nil]
       # @return [String]
-      def param_lookup(keys)
+      def get(name)
         raise DestroyedError unless @ptr
         self_p = @ptr
-        result = ::CZMQ::FFI.zargs_param_lookup(self_p, keys)
+        result = ::CZMQ::FFI.zargs_get(self_p, name)
         result
       end
 
-      # Return value of named parameter(s), NULL if no given parameter has
-      # been specified, or special value for wich zargs_param_empty ()
-      # returns true.
+      # Return value of one of parameter(s) or NULL is it has no value (or was not specified)
       #
-      # @param keys [String, #to_s, nil]
+      # @param name [String, #to_s, nil]
       # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
       # @return [String]
-      def param_lookupx(keys, *args)
+      def getx(name, *args)
         raise DestroyedError unless @ptr
         self_p = @ptr
-        result = ::CZMQ::FFI.zargs_param_lookupx(self_p, keys, *args)
+        result = ::CZMQ::FFI.zargs_getx(self_p, name, *args)
         result
       end
 
-      # Returns true if there are --help -h arguments
+      # Returns true if named parameter was specified on command line
       #
+      # @param name [String, #to_s, nil]
       # @return [Boolean]
-      def has_help()
+      def has(name)
         raise DestroyedError unless @ptr
         self_p = @ptr
-        result = ::CZMQ::FFI.zargs_has_help(self_p)
+        result = ::CZMQ::FFI.zargs_has(self_p, name)
         result
       end
 
-      # Returns true if parameter did not have a value
+      # Returns true if named parameter(s) was specified on command line
       #
-      # @param arg [String, #to_s, nil]
+      # @param name [String, #to_s, nil]
+      # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
       # @return [Boolean]
-      def self.param_empty(arg)
-        result = ::CZMQ::FFI.zargs_param_empty(arg)
+      def hasx(name, *args)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zargs_hasx(self_p, name, *args)
         result
       end
 

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

@@ -205,6 +205,16 @@ module CZMQ
         result
       end
 
+      # Return the state stored in certstore
+      #
+      # @return [::FFI::Pointer]
+      def state()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zcertstore_state(self_p)
+        result
+      end
+
       # Self test of this class
       #
       # @param verbose [Boolean]

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

@@ -73,6 +73,22 @@ module CZMQ
         @finalizer = nil
       end
 
+      # Create a new callback of the following type:
+      # Destroy an item
+      #     typedef void (zchunk_destructor_fn) (
+      #         void **hint);
+      #
+      # @note WARNING: If your Ruby code doesn't retain a reference to the
+      #   FFI::Function object after passing it to a C function call,
+      #   it may be garbage collected while C still holds the pointer,
+      #   potentially resulting in a segmentation fault.
+      def self.destructor_fn
+        ::FFI::Function.new :void, [:pointer], blocking: true do |hint|
+          result = yield hint
+          result
+        end
+      end
+
       # Create a new chunk of the specified size. If you specify the data, it
       # is copied into the chunk. If you do not specify the data, the chunk is
       # allocated and left empty, and you can then add data using zchunk_append.
@@ -85,6 +101,19 @@ module CZMQ
         __new ptr
       end
 
+      # Create a new chunk from memory. Take ownership of the memory and calling the destructor
+      # on destroy.
+      # @param data [::FFI::Pointer, #to_ptr]
+      # @param size [Integer, #to_int, #to_i]
+      # @param destructor [::FFI::Pointer, #to_ptr]
+      # @param hint [::FFI::Pointer, #to_ptr]
+      # @return [CZMQ::Zchunk]
+      def self.frommem(data, size, destructor, hint)
+        size = Integer(size)
+        ptr = ::CZMQ::FFI.zchunk_frommem(data, size, destructor, hint)
+        __new ptr
+      end
+
       # Destroy a chunk
       #
       # @return [void]
@@ -317,6 +346,18 @@ module CZMQ
         result
       end
 
+      # Transform zchunk into a zframe that can be sent in a message.
+      # Take ownership of the chunk.
+      #
+      # @param self_p [#__ptr_give_ref]
+      # @return [Zframe]
+      def self.packx(self_p)
+        self_p = self_p.__ptr_give_ref
+        result = ::CZMQ::FFI.zchunk_packx(self_p)
+        result = Zframe.__new result, true
+        result
+      end
+
       # Transform a zframe into a zchunk.
       #
       # @param frame [Zframe, #__ptr]

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

@@ -131,6 +131,19 @@ module CZMQ
         result
       end
 
+      # Create copy of zconfig, caller MUST free the value
+      # Create copy of config, as new zconfig object. Returns a fresh zconfig_t
+      # object. If config is null, or memory was exhausted, returns null.
+      #
+      # @return [Zconfig]
+      def dup()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zconfig_dup(self_p)
+        result = Zconfig.__new result, true
+        result
+      end
+
       # Return name of config item
       #
       # @return [::FFI::Pointer]
@@ -402,12 +415,22 @@ module CZMQ
         result
       end
 
-      # Destroy subtree (child)
+      # Destroy subtree (all children)
       #
       # @return [void]
-      def remove()
+      def remove_subtree()
         raise DestroyedError unless @ptr
         self_p = @ptr
+        result = ::CZMQ::FFI.zconfig_remove_subtree(self_p)
+        result
+      end
+
+      # Destroy node and subtree (all children)
+      #
+      # @param self_p [#__ptr_give_ref]
+      # @return [void]
+      def self.remove(self_p)
+        self_p = self_p.__ptr_give_ref
         result = ::CZMQ::FFI.zconfig_remove(self_p)
         result
       end

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

@@ -86,7 +86,7 @@ module CZMQ
         __new ptr
       end
 
-      # Create new temporary file for writing via tmpfile. File is automaticaly
+      # Create new temporary file for writing via tmpfile. File is automatically
       # deleted on destroy
       # @return [CZMQ::Zfile]
       def self.tmp()

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

@@ -82,6 +82,22 @@ module CZMQ
         @finalizer = nil
       end
 
+      # Create a new callback of the following type:
+      # Destroy an item
+      #     typedef void (zframe_destructor_fn) (
+      #         void **hint);
+      #
+      # @note WARNING: If your Ruby code doesn't retain a reference to the
+      #   FFI::Function object after passing it to a C function call,
+      #   it may be garbage collected while C still holds the pointer,
+      #   potentially resulting in a segmentation fault.
+      def self.destructor_fn
+        ::FFI::Function.new :void, [:pointer], blocking: true do |hint|
+          result = yield hint
+          result
+        end
+      end
+
       # Create a new frame. If size is not null, allocates the frame data
       # to the specified size. If additionally, data is not null, copies
       # size octets from the specified data into the frame body.
@@ -109,6 +125,19 @@ module CZMQ
         __new ptr
       end
 
+      # Create a new frame from memory. Take ownership of the memory and calling the destructor
+      # on destroy.
+      # @param data [::FFI::Pointer, #to_ptr]
+      # @param size [Integer, #to_int, #to_i]
+      # @param destructor [::FFI::Pointer, #to_ptr]
+      # @param hint [::FFI::Pointer, #to_ptr]
+      # @return [CZMQ::Zframe]
+      def self.frommem(data, size, destructor, hint)
+        size = Integer(size)
+        ptr = ::CZMQ::FFI.zframe_frommem(data, size, destructor, hint)
+        __new ptr
+      end
+
       # Receive frame from socket, returns zframe_t object or NULL if the recv
       # was interrupted. Does a blocking recv, if you want to not block then use
       # zpoller or zloop.
@@ -322,6 +351,7 @@ module CZMQ
 
       # Send message to zsys log sink (may be stdout, or system facility as
       # configured by zsys_set_logstream). Prefix shows before frame, if not null.
+      # Long messages are truncated.
       #
       # @param prefix [String, #to_s, nil]
       # @return [void]
@@ -332,6 +362,22 @@ module CZMQ
         result
       end
 
+      # Send message to zsys log sink (may be stdout, or system facility as
+      # configured by zsys_set_logstream). Prefix shows before frame, if not null.
+      # Message length is specified; no truncation unless length is zero.
+      # Backwards compatible with zframe_print when length is zero.
+      #
+      # @param prefix [String, #to_s, nil]
+      # @param length [Integer, #to_int, #to_i]
+      # @return [void]
+      def print_n(prefix, length)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        length = Integer(length)
+        result = ::CZMQ::FFI.zframe_print_n(self_p, prefix, length)
+        result
+      end
+
       # Probe the supplied object, and report if it looks like a zframe_t.
       #
       # @param self_ [::FFI::Pointer, #to_ptr]

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

@@ -0,0 +1,113 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+
+module CZMQ
+  module FFI
+
+    # Http client, allowing multiple requests simultaneously and integrate easily with zpoller.
+    # Use zhttp_request class to create and send the request.
+    # Use zhttp_response class to receive the response.
+    # @note This class is 100% generated using zproject.
+    class ZhttpClient
+      # Raised when one tries to use an instance of {ZhttpClient} after
+      # the internal pointer to the native object has been nullified.
+      class DestroyedError < RuntimeError; end
+
+      # Boilerplate for self pointer, initializer, and finalizer
+      class << self
+        alias :__new :new
+      end
+      # Attaches the pointer _ptr_ to this instance and defines a finalizer for
+      # it if necessary.
+      # @param ptr [::FFI::Pointer]
+      # @param finalize [Boolean]
+      def initialize(ptr, finalize = true)
+        @ptr = ptr
+        if @ptr.null?
+          @ptr = nil # Remove null pointers so we don't have to test for them.
+        elsif finalize
+          @finalizer = self.class.create_finalizer_for @ptr
+          ObjectSpace.define_finalizer self, @finalizer
+        end
+      end
+      # @param ptr [::FFI::Pointer]
+      # @return [Proc]
+      def self.create_finalizer_for(ptr)
+        Proc.new do
+          ptr_ptr = ::FFI::MemoryPointer.new :pointer
+          ptr_ptr.write_pointer ptr
+          ::CZMQ::FFI.zhttp_client_destroy ptr_ptr
+        end
+      end
+      # @return [Boolean]
+      def null?
+        !@ptr or @ptr.null?
+      end
+      # Return internal pointer
+      # @return [::FFI::Pointer]
+      def __ptr
+        raise DestroyedError unless @ptr
+        @ptr
+      end
+      # So external Libraries can just pass the Object to a FFI function which expects a :pointer
+      alias_method :to_ptr, :__ptr
+      # Nullify internal pointer and return pointer pointer.
+      # @note This detaches the current instance from the native object
+      #   and thus makes it unusable.
+      # @return [::FFI::MemoryPointer] the pointer pointing to a pointer
+      #   pointing to the native object
+      def __ptr_give_ref
+        raise DestroyedError unless @ptr
+        ptr_ptr = ::FFI::MemoryPointer.new :pointer
+        ptr_ptr.write_pointer @ptr
+        __undef_finalizer if @finalizer
+        @ptr = nil
+        ptr_ptr
+      end
+      # Undefines the finalizer for this object.
+      # @note Only use this if you need to and can guarantee that the native
+      #   object will be freed by other means.
+      # @return [void]
+      def __undef_finalizer
+        ObjectSpace.undefine_finalizer self
+        @finalizer = nil
+      end
+
+      # Create a new http client
+      # @param verbose [Boolean]
+      # @return [CZMQ::ZhttpClient]
+      def self.new(verbose)
+        verbose = !(0==verbose||!verbose) # boolean
+        ptr = ::CZMQ::FFI.zhttp_client_new(verbose)
+        __new ptr
+      end
+
+      # Destroy an http client
+      #
+      # @return [void]
+      def destroy()
+        return unless @ptr
+        self_p = __ptr_give_ref
+        result = ::CZMQ::FFI.zhttp_client_destroy(self_p)
+        result
+      end
+
+      # Self test of this class.
+      #
+      # @param verbose [Boolean]
+      # @return [void]
+      def self.test(verbose)
+        verbose = !(0==verbose||!verbose) # boolean
+        result = ::CZMQ::FFI.zhttp_client_test(verbose)
+        result
+      end
+    end
+  end
+end
+
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################

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

@@ -0,0 +1,312 @@
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################
+
+module CZMQ
+  module FFI
+
+    # Http request that can be received from zhttp_server or sent to zhttp_client.
+    # Class can be reused between send & recv calls.
+    # Headers and Content is being destroyed after every send call.
+    # @note This class is 100% generated using zproject.
+    class ZhttpRequest
+      # Raised when one tries to use an instance of {ZhttpRequest} after
+      # the internal pointer to the native object has been nullified.
+      class DestroyedError < RuntimeError; end
+
+      # Boilerplate for self pointer, initializer, and finalizer
+      class << self
+        alias :__new :new
+      end
+      # Attaches the pointer _ptr_ to this instance and defines a finalizer for
+      # it if necessary.
+      # @param ptr [::FFI::Pointer]
+      # @param finalize [Boolean]
+      def initialize(ptr, finalize = true)
+        @ptr = ptr
+        if @ptr.null?
+          @ptr = nil # Remove null pointers so we don't have to test for them.
+        elsif finalize
+          @finalizer = self.class.create_finalizer_for @ptr
+          ObjectSpace.define_finalizer self, @finalizer
+        end
+      end
+      # @param ptr [::FFI::Pointer]
+      # @return [Proc]
+      def self.create_finalizer_for(ptr)
+        Proc.new do
+          ptr_ptr = ::FFI::MemoryPointer.new :pointer
+          ptr_ptr.write_pointer ptr
+          ::CZMQ::FFI.zhttp_request_destroy ptr_ptr
+        end
+      end
+      # @return [Boolean]
+      def null?
+        !@ptr or @ptr.null?
+      end
+      # Return internal pointer
+      # @return [::FFI::Pointer]
+      def __ptr
+        raise DestroyedError unless @ptr
+        @ptr
+      end
+      # So external Libraries can just pass the Object to a FFI function which expects a :pointer
+      alias_method :to_ptr, :__ptr
+      # Nullify internal pointer and return pointer pointer.
+      # @note This detaches the current instance from the native object
+      #   and thus makes it unusable.
+      # @return [::FFI::MemoryPointer] the pointer pointing to a pointer
+      #   pointing to the native object
+      def __ptr_give_ref
+        raise DestroyedError unless @ptr
+        ptr_ptr = ::FFI::MemoryPointer.new :pointer
+        ptr_ptr.write_pointer @ptr
+        __undef_finalizer if @finalizer
+        @ptr = nil
+        ptr_ptr
+      end
+      # Undefines the finalizer for this object.
+      # @note Only use this if you need to and can guarantee that the native
+      #   object will be freed by other means.
+      # @return [void]
+      def __undef_finalizer
+        ObjectSpace.undefine_finalizer self
+        @finalizer = nil
+      end
+
+      # Create a new http request.
+      # @return [CZMQ::ZhttpRequest]
+      def self.new()
+        ptr = ::CZMQ::FFI.zhttp_request_new()
+        __new ptr
+      end
+
+      # Destroy an http request.
+      #
+      # @return [void]
+      def destroy()
+        return unless @ptr
+        self_p = __ptr_give_ref
+        result = ::CZMQ::FFI.zhttp_request_destroy(self_p)
+        result
+      end
+
+      # Receive a new request from zhttp_server.
+      # Return the underlying connection if successful, to be used when calling zhttp_response_send.
+      #
+      # @param sock [Zsock, #__ptr]
+      # @return [::FFI::Pointer]
+      def recv(sock)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        sock = sock.__ptr if sock
+        result = ::CZMQ::FFI.zhttp_request_recv(self_p, sock)
+        result
+      end
+
+      # Send a request to zhttp_client.
+      # Url and the request path will be concatenated.
+      # This behavior is useful for url rewrite and reverse proxy.
+      #
+      # Send also allow two user provided arguments which will be returned with the response.
+      # The reason for two, is to be able to pass around the server connection when forwarding requests or both a callback function and an arg.
+      #
+      # @param client [ZhttpClient, #__ptr]
+      # @param timeout [Integer, #to_int, #to_i]
+      # @param arg [::FFI::Pointer, #to_ptr]
+      # @param arg2 [::FFI::Pointer, #to_ptr]
+      # @return [Integer]
+      def send(client, timeout, arg, arg2)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        client = client.__ptr if client
+        timeout = Integer(timeout)
+        result = ::CZMQ::FFI.zhttp_request_send(self_p, client, timeout, arg, arg2)
+        result
+      end
+
+      # Get the request method
+      #
+      # @return [String]
+      def method()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_method(self_p)
+        result
+      end
+
+      # Set the request method
+      #
+      # @param method [String, #to_s, nil]
+      # @return [void]
+      def set_method(method)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_set_method(self_p, method)
+        result
+      end
+
+      # Get the request url.
+      # When receiving a request from http server this is only the path part of the url.
+      #
+      # @return [String]
+      def url()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_url(self_p)
+        result
+      end
+
+      # Set the request url
+      # When sending a request to http client this should be full url.
+      #
+      # @param url [String, #to_s, nil]
+      # @return [void]
+      def set_url(url)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_set_url(self_p, url)
+        result
+      end
+
+      # Get the request content type
+      #
+      # @return [String]
+      def content_type()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_content_type(self_p)
+        result
+      end
+
+      # Set the request content type
+      #
+      # @param content_type [String, #to_s, nil]
+      # @return [void]
+      def set_content_type(content_type)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_set_content_type(self_p, content_type)
+        result
+      end
+
+      # Get the content length of the request
+      #
+      # @return [Integer]
+      def content_length()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_content_length(self_p)
+        result
+      end
+
+      # Get the headers of the request
+      #
+      # @return [Zhash]
+      def headers()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_headers(self_p)
+        result = Zhash.__new result, false
+        result
+      end
+
+      # Get the content of the request.
+      #
+      # @return [String]
+      def content()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_content(self_p)
+        result
+      end
+
+      # Get the content of the request.
+      #
+      # @return [::FFI::AutoPointer]
+      def get_content()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_get_content(self_p)
+        result = ::FFI::AutoPointer.new(result, LibC.method(:free))
+        result
+      end
+
+      # Set the content of the request.
+      # Content must by dynamically allocated string.
+      # Takes ownership of the content.
+      #
+      # @param content [::FFI::Pointer, #to_ptr]
+      # @return [void]
+      def set_content(content)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_set_content(self_p, content)
+        result
+      end
+
+      # Set the content of the request..
+      # The content is assumed to be constant-memory and will therefore not be copied or deallocated in any way.
+      #
+      # @param content [String, #to_s, nil]
+      # @return [void]
+      def set_content_const(content)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_set_content_const(self_p, content)
+        result
+      end
+
+      # Set the content to NULL
+      #
+      # @return [void]
+      def reset_content()
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_reset_content(self_p)
+        result
+      end
+
+      # Match the path of the request.
+      # Support wildcards with '%s' symbol inside the match string.
+      # Matching wildcards until the next '/', '?' or '\0'.
+      # On successful match the variadic arguments will be filled with the matching strings.
+      # On successful match the method is modifying the url field and break it into substrings.
+      # If you need to use the url, do it before matching or take a copy.
+      #
+      # User must not free the variadic arguments as they are part of the url.
+      #
+      # To use the percent symbol, just double it, e.g "%%something".
+      #
+      # Example:
+      # if (zhttp_request_match (request, "POST", "/send/%s/%s", &name, &id))
+      #
+      # @param method [String, #to_s, nil]
+      # @param path [String, #to_s, nil]
+      # @param args [Array<Object>] see https://github.com/ffi/ffi/wiki/examples#using-varargs
+      # @return [Boolean]
+      def match(method, path, *args)
+        raise DestroyedError unless @ptr
+        self_p = @ptr
+        result = ::CZMQ::FFI.zhttp_request_match(self_p, method, path, *args)
+        result
+      end
+
+      # Self test of this class.
+      #
+      # @param verbose [Boolean]
+      # @return [void]
+      def self.test(verbose)
+        verbose = !(0==verbose||!verbose) # boolean
+        result = ::CZMQ::FFI.zhttp_request_test(verbose)
+        result
+      end
+    end
+  end
+end
+
+################################################################################
+#  THIS FILE IS 100% GENERATED BY ZPROJECT; DO NOT EDIT EXCEPT EXPERIMENTALLY  #
+#  Read the zproject/README.md for information about making permanent changes. #
+################################################################################