GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages
Mojo::Reactor(3) User Contributed Perl Documentation Mojo::Reactor(3)
 

Mojo::Reactor - Low-level event reactor base class

  package Mojo::Reactor::MyEventLoop;
  use Mojo::Base 'Mojo::Reactor';
  sub again      {...}
  sub io         {...}
  sub is_running {...}
  sub next_tick  {...}
  sub one_tick   {...}
  sub recurring  {...}
  sub remove     {...}
  sub reset      {...}
  sub start      {...}
  sub stop       {...}
  sub timer      {...}
  sub watch      {...}

Mojo::Reactor is an abstract base class for low-level event reactors, like Mojo::Reactor::EV and Mojo::Reactor::Poll.

Mojo::Reactor inherits all events from Mojo::EventEmitter and can emit the following new ones.

  $reactor->on(error => sub {
    my ($reactor, $err) = @_;
    ...
  });
Emitted for exceptions caught in callbacks, fatal if unhandled. Note that if this event is unhandled or fails it might kill your program, so you need to be careful.
  $reactor->on(error => sub {
    my ($reactor, $err) = @_;
    say "Something very bad happened: $err";
  });

Mojo::Reactor inherits all methods from Mojo::EventEmitter and implements the following new ones.

  $reactor->again($id);
Restart timer. Meant to be overloaded in a subclass. Note that this method requires an active timer.

  my $class = Mojo::Reactor->detect;
Detect and load the best reactor implementation available, will try the value of the "MOJO_REACTOR" environment variable, Mojo::Reactor::EV or Mojo::Reactor::Poll.
  # Instantiate best reactor implementation available
  my $reactor = Mojo::Reactor->detect->new;

  $reactor = $reactor->io($handle => sub {...});
Watch handle for I/O events, invoking the callback whenever handle becomes readable or writable. Meant to be overloaded in a subclass.
  # Callback will be executed twice if handle becomes readable and writable
  $reactor->io($handle => sub {
    my ($reactor, $writable) = @_;
    say $writable ? 'Handle is writable' : 'Handle is readable';
  });

  my $bool = $reactor->is_running;
Check if reactor is running. Meant to be overloaded in a subclass.

  my $undef = $reactor->next_tick(sub {...});
Execute callback as soon as possible, but not before returning or other callbacks that have been registered with this method, always returns "undef". Meant to be overloaded in a subclass.

  $reactor->one_tick;
Run reactor until an event occurs. Note that this method can recurse back into the reactor, so you need to be careful. Meant to be overloaded in a subclass.
  # Don't block longer than 0.5 seconds
  my $id = $reactor->timer(0.5 => sub {});
  $reactor->one_tick;
  $reactor->remove($id);

  my $id = $reactor->recurring(0.25 => sub {...});
Create a new recurring timer, invoking the callback repeatedly after a given amount of time in seconds. Meant to be overloaded in a subclass.

  my $bool = $reactor->remove($handle);
  my $bool = $reactor->remove($id);
Remove handle or timer. Meant to be overloaded in a subclass.

  $reactor->reset;
Remove all handles and timers. Meant to be overloaded in a subclass.

  $reactor->start;
Start watching for I/O and timer events, this will block until "stop" is called. Note that some reactors stop automatically if there are no events being watched anymore. Meant to be overloaded in a subclass.
  # Start reactor only if it is not running already
  $reactor->start unless $reactor->is_running;

  $reactor->stop;
Stop watching for I/O and timer events. Meant to be overloaded in a subclass.

  my $id = $reactor->timer(0.5 => sub {...});
Create a new timer, invoking the callback after a given amount of time in seconds. Meant to be overloaded in a subclass.

  $reactor = $reactor->watch($handle, $readable, $writable);
Change I/O events to watch handle for with true and false values. Meant to be overloaded in a subclass. Note that this method requires an active I/O watcher.
  # Watch only for readable events
  $reactor->watch($handle, 1, 0);
  # Watch only for writable events
  $reactor->watch($handle, 0, 1);
  # Watch for readable and writable events
  $reactor->watch($handle, 1, 1);
  # Pause watching for events
  $reactor->watch($handle, 0, 0);

Mojolicious, Mojolicious::Guides, <https://mojolicious.org>.
2018-11-22 perl v5.28.1

Search for    or go to Top of page |  Section 3 |  Main Index

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with ManDoc.