class CZMQ::FFI::Zchunk

work with memory chunks @note This class is 100% generated using zproject.

Public Class Methods

__new(data, size)
Alias for: new
create_finalizer_for(ptr) click to toggle source

@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
destructor_fn() { |hint| ... } click to toggle source

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
frommem(data, size, destructor, hint) click to toggle source

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
is(self_) click to toggle source

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
new(ptr, finalize = true) click to toggle source

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
new(data, size) click to toggle source

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
Also aliased as: __new
packx(self_p) click to toggle source

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(handle, bytes) click to toggle source

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
slurp(filename, maxsize) click to toggle source

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
test(verbose) click to toggle source

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
unpack(frame) click to toggle source

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

__ptr() click to toggle source

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
Also aliased as: to_ptr
__ptr_give_ref() click to toggle source

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
__undef_finalizer() click to toggle source

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(data, size) click to toggle source

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
consume(source) click to toggle source

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
data() click to toggle source

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() click to toggle source

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
digest() click to toggle source

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
dup() click to toggle source

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
exhausted() click to toggle source

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
extend(data, size) click to toggle source

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(filler, size) click to toggle source

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
fprint(file) click to toggle source

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
max_size() click to toggle source

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
null?() click to toggle source

@return [Boolean]

# File lib/czmq-ffi-gen/czmq/ffi/zchunk.rb, line 43
def null?
  !@ptr or @ptr.null?
end
pack() click to toggle source

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
print() click to toggle source

Dump message to stderr, for debugging and tracing. See zchunk_fprint for details

@return [void]

resize(size) click to toggle source

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(data, size) click to toggle source

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
size() click to toggle source

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
strdup() click to toggle source

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
streq(string) click to toggle source

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
strhex() click to toggle source

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
to_ptr()

So external Libraries can just pass the Object to a FFI function which expects a :pointer

Alias for: __ptr
write(handle) click to toggle source

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