Class: CZMQ::FFI::Zloop

Inherits:
Object
  • Object
show all
Defined in:
lib/czmq-ffi-gen/czmq/ffi/zloop.rb

Overview

Note:

This class is 100% generated using zproject.

event-driven reactor

Defined Under Namespace

Classes: DestroyedError

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(ptr, finalize = true) ⇒ Zloop

Attaches the pointer ptr to this instance and defines a finalizer for it if necessary.

Parameters:

  • ptr (::FFI::Pointer)
  • finalize (Boolean) (defaults to: true) 


24
25
26
27
28
29
30
31
32
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.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

Class Method Details

.__new ⇒ Object 



18
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 18

alias :__new :new

.create_finalizer_for(ptr) ⇒ Proc

Parameters:

  • ptr (::FFI::Pointer)

Returns:

  • (Proc) 


35
36
37
38
39
40
41
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.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.zloop_destroy ptr_ptr
  end
end

.fn ⇒ Object

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.

Create a new callback of the following type: Callback function for reactor events (low-level)

typedef int (zloop_fn) (
    zloop_t *loop, zmq_pollitem_t *item, void *arg);



104
105
106
107
108
109
110
111
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 104

def self.fn
  ::FFI::Function.new :int, [:pointer, :pointer, :pointer], blocking: true do |loop, item, arg|
    loop = Zloop.__new loop, false
    result = yield loop, item, arg
    result = Integer(result)
    result
  end
end

.new ⇒ CZMQ::Zloop

Create a new zloop reactor

Returns:

  • (CZMQ::Zloop) 


133
134
135
136
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 133

def self.new()
  ptr = ::CZMQ::FFI.zloop_new()
  __new ptr
end

.reader_fn ⇒ Object

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.

Create a new callback of the following type: Callback function for reactor socket activity

typedef int (zloop_reader_fn) (
    zloop_t *loop, zsock_t *reader, void *arg);



85
86
87
88
89
90
91
92
93
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 85

def self.reader_fn
  ::FFI::Function.new :int, [:pointer, :pointer, :pointer], blocking: true do |loop, reader, arg|
    loop = Zloop.__new loop, false
    reader = Zsock.__new reader, false
    result = yield loop, reader, arg
    result = Integer(result)
    result
  end
end

.test(verbose) ⇒ void

This method returns an undefined value.

Self test of this class.

Parameters:

  • verbose (Boolean) 


384
385
386
387
388
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 384

def self.test(verbose)
  verbose = !(0==verbose||!verbose) # boolean
  result = ::CZMQ::FFI.zloop_test(verbose)
  result
end

.timer_fn ⇒ Object

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.

Create a new callback of the following type: Callback for reactor timer events

typedef int (zloop_timer_fn) (
    zloop_t *loop, int timer_id, void *arg);



122
123
124
125
126
127
128
129
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 122

def self.timer_fn
  ::FFI::Function.new :int, [:pointer, :int, :pointer], blocking: true do |loop, timer_id, arg|
    loop = Zloop.__new loop, false
    result = yield loop, timer_id, arg
    result = Integer(result)
    result
  end
end

Instance Method Details

#__ptr ⇒ ::FFI::Pointer Also known as: to_ptr

Return internal pointer

Returns:

  • (::FFI::Pointer)

Raises:



48
49
50
51
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 48

def __ptr
  raise DestroyedError unless @ptr
  @ptr
end

#__ptr_give_ref ⇒ ::FFI::MemoryPointer

Note:

This detaches the current instance from the native object and thus makes it unusable.

Nullify internal pointer and return pointer pointer.

Returns:

  • (::FFI::MemoryPointer) —

    the pointer pointing to a pointer pointing to the native object

Raises:



59
60
61
62
63
64
65
66
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.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 ⇒ void

Note:

Only use this if you need to and can guarantee that the native object will be freed by other means.

This method returns an undefined value.

Undefines the finalizer for this object.



71
72
73
74
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 71

def __undef_finalizer
  ObjectSpace.undefine_finalizer self
  @finalizer = nil
end

#destroy ⇒ void

This method returns an undefined value.

Destroy a reactor



141
142
143
144
145
146
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 141

def destroy()
  return unless @ptr
  self_p = __ptr_give_ref
  result = ::CZMQ::FFI.zloop_destroy(self_p)
  result
end

#null? ⇒ Boolean

Returns:

  • (Boolean) 


43
44
45
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 43

def null?
  !@ptr or @ptr.null?
end

#poller(item, handler, arg) ⇒ Integer

Register low-level libzmq pollitem with the reactor. When the pollitem is ready, will call the handler, passing the arg. Returns 0 if OK, -1 if there was an error. If you register the pollitem more than once, each instance will invoke its corresponding handler. A pollitem with socket=NULL and fd=0 means ‘poll on FD zero’.

Parameters:

  • item (::FFI::Pointer, #to_ptr)
  • handler (::FFI::Pointer, #to_ptr)
  • arg (::FFI::Pointer, #to_ptr)

Returns:

  • (Integer)

Raises:



201
202
203
204
205
206
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 201

def poller(item, handler, arg)
  raise DestroyedError unless @ptr
  self_p = @ptr
  result = ::CZMQ::FFI.zloop_poller(self_p, item, handler, arg)
  result
end

#poller_end(item) ⇒ void

This method returns an undefined value.

Cancel a pollitem from the reactor, specified by socket or FD. If both are specified, uses only socket. If multiple poll items exist for same socket/FD, cancels ALL of them.

Parameters:

  • item (::FFI::Pointer, #to_ptr)

Raises:



214
215
216
217
218
219
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 214

def poller_end(item)
  raise DestroyedError unless @ptr
  self_p = @ptr
  result = ::CZMQ::FFI.zloop_poller_end(self_p, item)
  result
end

#poller_set_tolerant(item) ⇒ void

This method returns an undefined value.

Configure a registered poller to ignore errors. If you do not set this, then poller that have errors are removed from the reactor silently.

Parameters:

  • item (::FFI::Pointer, #to_ptr)

Raises:



226
227
228
229
230
231
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 226

def poller_set_tolerant(item)
  raise DestroyedError unless @ptr
  self_p = @ptr
  result = ::CZMQ::FFI.zloop_poller_set_tolerant(self_p, item)
  result
end

#reader(sock, handler, arg) ⇒ Integer

Register socket reader with the reactor. When the reader has messages, the reactor will call the handler, passing the arg. Returns 0 if OK, -1 if there was an error. If you register the same socket more than once, each instance will invoke its corresponding handler.

Parameters:

Returns:

  • (Integer)

Raises:



157
158
159
160
161
162
163
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 157

def reader(sock, handler, arg)
  raise DestroyedError unless @ptr
  self_p = @ptr
  sock = sock.__ptr if sock
  result = ::CZMQ::FFI.zloop_reader(self_p, sock, handler, arg)
  result
end

#reader_end(sock) ⇒ void

This method returns an undefined value.

Cancel a socket reader from the reactor. If multiple readers exist for same socket, cancels ALL of them.

Parameters:

Raises:



170
171
172
173
174
175
176
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 170

def reader_end(sock)
  raise DestroyedError unless @ptr
  self_p = @ptr
  sock = sock.__ptr if sock
  result = ::CZMQ::FFI.zloop_reader_end(self_p, sock)
  result
end

#reader_set_tolerant(sock) ⇒ void

This method returns an undefined value.

Configure a registered reader to ignore errors. If you do not set this, then readers that have errors are removed from the reactor silently.

Parameters:

Raises:



183
184
185
186
187
188
189
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 183

def reader_set_tolerant(sock)
  raise DestroyedError unless @ptr
  self_p = @ptr
  sock = sock.__ptr if sock
  result = ::CZMQ::FFI.zloop_reader_set_tolerant(self_p, sock)
  result
end

#set_max_timers(max_timers) ⇒ void

This method returns an undefined value.

Set hard limit on number of timers allowed. Setting more than a small number of timers (10-100) can have a dramatic impact on the performance of the reactor. For high-volume cases, use ticket timers. If the hard limit is reached, the reactor stops creating new timers and logs an error.

Parameters:

  • max_timers (Integer, #to_int, #to_i)

Raises:



331
332
333
334
335
336
337
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 331

def set_max_timers(max_timers)
  raise DestroyedError unless @ptr
  self_p = @ptr
  max_timers = Integer(max_timers)
  result = ::CZMQ::FFI.zloop_set_max_timers(self_p, max_timers)
  result
end

#set_nonstop(nonstop) ⇒ void

This method returns an undefined value.

By default the reactor stops if the process receives a SIGINT or SIGTERM signal. This makes it impossible to shut-down message based architectures like zactors. This method lets you switch off break handling. The default nonstop setting is off (false).

Parameters:

  • nonstop (Boolean)

Raises:



359
360
361
362
363
364
365
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 359

def set_nonstop(nonstop)
  raise DestroyedError unless @ptr
  self_p = @ptr
  nonstop = !(0==nonstop||!nonstop) # boolean
  result = ::CZMQ::FFI.zloop_set_nonstop(self_p, nonstop)
  result
end

#set_ticket_delay(ticket_delay) ⇒ void

This method returns an undefined value.

Set the ticket delay, which applies to all tickets. If you lower the delay and there are already tickets created, the results are undefined.

Parameters:

  • ticket_delay (Integer, #to_int, #to_i)

Raises:



315
316
317
318
319
320
321
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 315

def set_ticket_delay(ticket_delay)
  raise DestroyedError unless @ptr
  self_p = @ptr
  ticket_delay = Integer(ticket_delay)
  result = ::CZMQ::FFI.zloop_set_ticket_delay(self_p, ticket_delay)
  result
end

#set_verbose(verbose) ⇒ void

This method returns an undefined value.

Set verbose tracing of reactor on/off. The default verbose setting is off (false).

Parameters:

  • verbose (Boolean)

Raises:



344
345
346
347
348
349
350
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 344

def set_verbose(verbose)
  raise DestroyedError unless @ptr
  self_p = @ptr
  verbose = !(0==verbose||!verbose) # boolean
  result = ::CZMQ::FFI.zloop_set_verbose(self_p, verbose)
  result
end

#start ⇒ Integer

Start the reactor. Takes control of the thread and returns when the 0MQ context is terminated or the process is interrupted, or any event handler returns -1. Event handlers may register new sockets and timers, and cancel sockets. Returns 0 if interrupted, -1 if canceled by a handler.

Returns:

  • (Integer)

Raises:



373
374
375
376
377
378
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 373

def start()
  raise DestroyedError unless @ptr
  self_p = @ptr
  result = ::CZMQ::FFI.zloop_start(self_p)
  result
end

#ticket(handler, arg) ⇒ ::FFI::Pointer

Register a ticket timer. Ticket timers are very fast in the case where you use a lot of timers (thousands), and frequently remove and add them. The main use case is expiry timers for servers that handle many clients, and which reset the expiry timer for each message received from a client. Whereas normal timers perform poorly as the number of clients grows, the cost of ticket timers is constant, no matter the number of clients. You must set the ticket delay using zloop_set_ticket_delay before creating a ticket. Returns a handle to the timer that you should use in zloop_ticket_reset and zloop_ticket_delete.

Parameters:

  • handler (::FFI::Pointer, #to_ptr)
  • arg (::FFI::Pointer, #to_ptr)

Returns:

  • (::FFI::Pointer)

Raises:



278
279
280
281
282
283
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 278

def ticket(handler, arg)
  raise DestroyedError unless @ptr
  self_p = @ptr
  result = ::CZMQ::FFI.zloop_ticket(self_p, handler, arg)
  result
end

#ticket_delete(handle) ⇒ void

This method returns an undefined value.

Delete a ticket timer. We do not actually delete the ticket here, as other code may still refer to the ticket. We mark as deleted, and remove later and safely.

Parameters:

  • handle (::FFI::Pointer, #to_ptr)

Raises:



303
304
305
306
307
308
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 303

def ticket_delete(handle)
  raise DestroyedError unless @ptr
  self_p = @ptr
  result = ::CZMQ::FFI.zloop_ticket_delete(self_p, handle)
  result
end

#ticket_reset(handle) ⇒ void

This method returns an undefined value.

Reset a ticket timer, which moves it to the end of the ticket list and resets its execution time. This is a very fast operation.

Parameters:

  • handle (::FFI::Pointer, #to_ptr)

Raises:



290
291
292
293
294
295
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 290

def ticket_reset(handle)
  raise DestroyedError unless @ptr
  self_p = @ptr
  result = ::CZMQ::FFI.zloop_ticket_reset(self_p, handle)
  result
end

#timer(delay, times, handler, arg) ⇒ Integer

Register a timer that expires after some delay and repeats some number of times. At each expiry, will call the handler, passing the arg. To run a timer forever, use 0 times. Returns a timer_id that is used to cancel the timer in the future. Returns -1 if there was an error.

Parameters:

  • delay (Integer, #to_int, #to_i)
  • times (Integer, #to_int, #to_i)
  • handler (::FFI::Pointer, #to_ptr)
  • arg (::FFI::Pointer, #to_ptr)

Returns:

  • (Integer)

Raises:



243
244
245
246
247
248
249
250
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 243

def timer(delay, times, handler, arg)
  raise DestroyedError unless @ptr
  self_p = @ptr
  delay = Integer(delay)
  times = Integer(times)
  result = ::CZMQ::FFI.zloop_timer(self_p, delay, times, handler, arg)
  result
end

#timer_end(timer_id) ⇒ Integer

Cancel a specific timer identified by a specific timer_id (as returned by zloop_timer).

Parameters:

  • timer_id (Integer, #to_int, #to_i)

Returns:

  • (Integer)

Raises:



257
258
259
260
261
262
263
 
# File 'lib/czmq-ffi-gen/czmq/ffi/zloop.rb', line 257

def timer_end(timer_id)
  raise DestroyedError unless @ptr
  self_p = @ptr
  timer_id = Integer(timer_id)
  result = ::CZMQ::FFI.zloop_timer_end(self_p, timer_id)
  result
end