class CZMQ::FFI::Zchunk
work with memory chunks @note This class is 100% generated using zproject.
Public Class Methods
@param ptr [::FFI::Pointer] @return [Proc]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 35 def self.create_finalizer_for(ptr) Proc.new do ptr_ptr = ::FFI::MemoryPointer.new :pointer ptr_ptr.write_pointer ptr ::CZMQ::FFI.zchunk_destroy ptr_ptr end 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.
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 85 def self.destructor_fn ::FFI::Function.new :void, [:pointer], blocking: true do |hint| result = yield hint result end 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]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 111 def self.frommem(data, size, destructor, hint) size = Integer(size) ptr = ::CZMQ::FFI.zchunk_frommem(data, size, destructor, hint) __new ptr end
Probe the supplied object, and report if it looks like a zchunk_t.
@param self_ [::FFI::Pointer, to_ptr
] @return [Boolean]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 408 def self.is(self_) result = ::CZMQ::FFI.zchunk_is(self_) result end
Attaches the pointer ptr to this instance and defines a finalizer for it if necessary. @param ptr [::FFI::Pointer] @param finalize [Boolean]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 24 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
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. @param data [::FFI::Pointer, to_ptr
] @param size [Integer, to_int, to_i] @return [CZMQ::Zchunk]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 98 def self.new(data, size) size = Integer(size) ptr = ::CZMQ::FFI.zchunk_new(data, size) __new ptr 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]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 354 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
Read chunk from an open file descriptor
@param handle [::FFI::Pointer, to_ptr
] @param bytes [Integer, to_int, to_i] @return [Zchunk]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 257 def self.read(handle, bytes) bytes = Integer(bytes) result = ::CZMQ::FFI.zchunk_read(handle, bytes) result = Zchunk.__new result, true result end
Try to slurp an entire file into a chunk. Will read up to maxsize of the file. If maxsize is 0, will attempt to read the entire file and fail with an assertion if that cannot fit into memory. Returns a new chunk containing the file data, or NULL if the file could not be read.
@param filename [String, to_s, nil] @param maxsize [Integer, to_int, to_i] @return [Zchunk]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 283 def self.slurp(filename, maxsize) maxsize = Integer(maxsize) result = ::CZMQ::FFI.zchunk_slurp(filename, maxsize) result = Zchunk.__new result, true result end
Self test of this class.
@param verbose [Boolean] @return [void]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 417 def self.test(verbose) verbose = !(0==verbose||!verbose) # boolean result = ::CZMQ::FFI.zchunk_test(verbose) result end
Transform a zframe into a zchunk.
@param frame [Zframe, #__ptr] @return [Zchunk]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 365 def self.unpack(frame) frame = frame.__ptr if frame result = ::CZMQ::FFI.zchunk_unpack(frame) result = Zchunk.__new result, true result end
Public Instance Methods
Return internal pointer @return [::FFI::Pointer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 48 def __ptr raise DestroyedError unless @ptr @ptr end
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
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 59 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]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 71 def __undef_finalizer ObjectSpace.undefine_finalizer self @finalizer = nil end
Append user-supplied data to chunk, return resulting chunk size. If the data would exceeded the available space, it is truncated. If you want to grow the chunk to accommodate new data, use the zchunk_extend method.
@param data [::FFI::Pointer, to_ptr
] @param size [Integer, to_int, to_i] @return [Integer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 204 def append(data, size) raise DestroyedError unless @ptr self_p = @ptr size = Integer(size) result = ::CZMQ::FFI.zchunk_append(self_p, data, size) result end
Copy as much data from 'source' into the chunk as possible; returns the new size of chunk. If all data from 'source' is used, returns exhausted on the source chunk. Source can be consumed as many times as needed until it is exhausted. If source was already exhausted, does not change chunk.
@param source [Zchunk, #__ptr] @return [Integer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 233 def consume(source) raise DestroyedError unless @ptr self_p = @ptr source = source.__ptr if source result = ::CZMQ::FFI.zchunk_consume(self_p, source) result end
Return chunk data
@return [::FFI::Pointer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 162 def data() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_data(self_p) result end
Destroy a chunk
@return [void]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 120 def destroy() return unless @ptr self_p = __ptr_give_ref result = ::CZMQ::FFI.zchunk_destroy(self_p) result end
Calculate SHA1 digest for chunk, using zdigest class.
@return [String]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 375 def digest() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_digest(self_p) result end
Create copy of chunk, as new chunk object. Returns a fresh zchunk_t object, or null if there was not enough heap memory. If chunk is null, returns null.
@return [Zchunk]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 295 def dup() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_dup(self_p) result = Zchunk.__new result, true result end
Returns true if the chunk was exhausted by consume methods, or if the chunk has a size of zero.
@return [Boolean]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 245 def exhausted() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_exhausted(self_p) result end
Append user-supplied data to chunk, return resulting chunk size. If the data would exceeded the available space, the chunk grows in size.
@param data [::FFI::Pointer, to_ptr
] @param size [Integer, to_int, to_i] @return [Integer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 218 def extend(data, size) raise DestroyedError unless @ptr self_p = @ptr size = Integer(size) result = ::CZMQ::FFI.zchunk_extend(self_p, data, size) result end
Fill chunk data from user-supplied octet
@param filler [Integer, to_int, to_i] @param size [Integer, to_int, to_i] @return [Integer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 188 def fill(filler, size) raise DestroyedError unless @ptr self_p = @ptr filler = Integer(filler) size = Integer(size) result = ::CZMQ::FFI.zchunk_fill(self_p, filler, size) result end
Dump chunk to FILE stream, for debugging and tracing.
@param file [::FFI::Pointer, to_ptr
] @return [void]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 386 def fprint(file) raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_fprint(self_p, file) result end
Return chunk max size
@return [Integer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 152 def max_size() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_max_size(self_p) result end
@return [Boolean]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 43 def null? !@ptr or @ptr.null? end
Transform zchunk into a zframe that can be sent in a message.
@return [Zframe]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 341 def pack() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_pack(self_p) result = Zframe.__new result, true result end
Dump message to stderr, for debugging and tracing. See zchunk_fprint for details
@return [void]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 397 def print() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_print(self_p) result end
Resizes chunk max_size
as requested; chunk_cur size is set to zero
@param size [Integer, to_int, to_i] @return [void]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 131 def resize(size) raise DestroyedError unless @ptr self_p = @ptr size = Integer(size) result = ::CZMQ::FFI.zchunk_resize(self_p, size) result end
Set chunk data from user-supplied data; truncate if too large. Data may be null. Returns actual size of chunk
@param data [::FFI::Pointer, to_ptr
] @param size [Integer, to_int, to_i] @return [Integer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 175 def set(data, size) raise DestroyedError unless @ptr self_p = @ptr size = Integer(size) result = ::CZMQ::FFI.zchunk_set(self_p, data, size) result end
Return chunk cur size
@return [Integer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 142 def size() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_size(self_p) result end
Return chunk data copied into freshly allocated string Caller must free string when finished with it.
@return [::FFI::AutoPointer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 319 def strdup() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_strdup(self_p) result = ::FFI::AutoPointer.new(result, LibC.method(:free)) result end
Return TRUE if chunk body is equal to string, excluding terminator
@param string [String, to_s, nil] @return [Boolean]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 331 def streq(string) raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_streq(self_p, string) result end
Return chunk data encoded as printable hex string. Caller must free string when finished with it.
@return [::FFI::AutoPointer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 307 def strhex() raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_strhex(self_p) result = ::FFI::AutoPointer.new(result, LibC.method(:free)) result end
So external Libraries can just pass the Object to a FFI
function which expects a :pointer
Write chunk to an open file descriptor
@param handle [::FFI::Pointer, to_ptr
] @return [Integer]
# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 268 def write(handle) raise DestroyedError unless @ptr self_p = @ptr result = ::CZMQ::FFI.zchunk_write(self_p, handle) result end