Event::RPC::Loop - Mainloop Abstraction layer for Event::RPC

         Jörn Reder <joern AT zyn.de>

       Copyright (C) 2005-2015 by Jörn Reder <joern AT zyn.de>.

       This library is free software; you can redistribute it and/or modify it under  the  same  terms  as  Perl
       itself.

perl v5.36.0                                       2022-12-12                              Event::RPC::Loop(3pm)

       This modules defines the interface of Event::RPC's mainloop abstraction layer. It's a virtual class all
       mainloop modules should inherit from.

       You may use the methods of Event::RPC::Loop by  yourself  if  you  like.  This  way  your  program  keeps
       independent  of  the  actual  mainloop  module in use, if the simplified interface of Event::RPC::Loop is
       sufficient for you.

       In your server program you access the actual mainloop object this way:

         my $loop = Event::RPC::Server->instance->get_loop;

       Naturally  nothing  speaks  against  making  your  program  to  work  only  with  a   specific   mainloop
       implementation,  if  you need its features. In that case you may use the corresponding API directly (e.g.
       of Event or Glib), no need to access it through Event::RPC::Loop.

       The following methods need to be implemented:

       $loop->enter ()
           Enter resp. start a mainloop.

       $loop->leave ()
           Leave the mainloop, which was started with the enter() method.

       $watcher = $loop->add_io_watcher ( %options )
           Add an I/O watcher. Options are passed as a hash of key/value pairs. The following options are known:

           fh  The filehandle to be watched.

           cb  This callback is called, without any parameters, if an event occurred on the filehandle above.

           desc
               A description of the watcher. Not necessarily implemented by all modules, so it may be ignored.

           poll
               Either 'r', if your program reads from the filehandle, or 'w' if it writes to it.

           A  watcher  object  is  returned. What this exactly is depends on the implementation, so you can't do
           anything useful with it besides passing it back to del_io_watcher().

       $loop->del_io_watcher ( $watcher )
           Deletes an I/O watcher which was added with $loop->add_io_watcher().

       $timer = $loop->add_timer ( %options )
           This sets a timer, a subroutine called after a specific timeout or on a regularly basis with a  fixed
           time interval.

           Options are passed as a hash of key/value pairs. The following options are known:

           interval
               A time interval in seconds, may be fractional.

           after
               Callback is called once after this amount of seconds, may be fractional.

           cb  The callback.

           desc
               A description of the timer. Not necessarily implemented by all modules, so it may be ignored.

           A  timer  object  is  returned.  What  this exactly is depends on the implementation, so you can't do
           anything useful with it besides passing it back to del_io_timer().

       $loop->del_timer ( $timer )
           Deletes a timer which was added with $loop->add_timer().

       Event::RPC::Loop - Mainloop Abstraction layer for Event::RPC

         use Event::RPC::Server;
         use Event::RPC::Loop::Glib;

         my $server = Event::RPC::Server->new (
             ...
             loop => Event::RPC::Loop::Glib->new(),
             ...
         );

         $server->start;