The factory constructor optionally takes a string as an argument. It will copy this string to native memory in preparation for transmission. So, don‘t pass a string unless you intend to send it. Internally it calls copy_in_string.

Call close to release buffers when you are done with the data.

(This class is not really zero-copy. Ruby makes this near impossible since Ruby objects can be relocated in memory by the GC at any time. There is no way to peg them to native memory or have them use non-movable native memory as backing store.)

Message represents ruby equivalent of the zmq_msg_t C struct. Access the underlying memory buffer and the buffer size using the data and size methods respectively.

It is recommended that this class be composed inside another class for access to the underlying buffer. The outer wrapper class can provide nice accessors for the information in the data buffer; a clever implementation can probably lazily encode/decode the data buffer on demand. Lots of protocols send more information than is strictly necessary, so only decode (copy from the 0mq buffer to Ruby) that which is necessary.

When you are done using a received message object, call close to release the associated buffers.

 received_message = Message.create
 if received_message
   rc = socket.recvmsg(received_message)
   if ZMQ::Util.resultcode_ok?(rc)
     puts "Message contained: #{received_message.copy_out_string}"
   else
     STDERR.puts "Error when receiving message: #{ZMQ::Util.error_string}"
   end

Define a custom layout for the data sent between 0mq peers.

 class MyMessage
   class Layout < FFI::Struct
     layout :value1, :uint8,
            :value2, :uint64,
            :value3, :uint32,
            :value4, [:char, 30]
   end

   def initialize msg_struct = nil
     if msg_struct
       @msg_t = msg_struct
       @data = Layout.new(@msg_t.data)
     else
       @pointer = FFI::MemoryPointer.new :byte, Layout.size, true
       @data = Layout.new @pointer
     end
   end

   def size() @size = @msg_t.size; end

   def value1
     @data[:value1]
   end

   def value4
     @data[:value4].to_ptr.read_string
   end

   def value1=(val)
     @data[:value1] = val
   end

   def create_sendable_message
     msg = Message.new
     msg.copy_in_bytes @pointer, Layout.size
   end

 message = Message.new
 successful_read = socket.recv message
 message = MyMessage.new message if successful_read
 puts "value1 is #{message.value1}"