This file is indexed.

/usr/share/perl5/Event/RPC/Loop.pm is in libevent-rpc-perl 1.04-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
# $Id: Loop.pm,v 1.4 2009-04-22 10:53:51 joern Exp $

#-----------------------------------------------------------------------
# Copyright (C) 2002-2006 Jörn Reder <joern AT zyn.de>.
# All Rights Reserved. See file COPYRIGHT for details.
# 
# This module is part of Event::RPC, which is free software; you can
# redistribute it and/or modify it under the same terms as Perl itself.
#-----------------------------------------------------------------------

package Event::RPC::Loop;

sub new {
    my $class = shift;
    return bless {}, $class;
}

1;

__END__

=encoding latin1

=head1 NAME

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

=head1 SYNOPSIS

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

  $server->start;

=head1 DESCRIPTION

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

=head1 INTERFACE

The following methods need to be implemented:

=over 4

=item $loop->B<enter> ()

Enter resp. start a mainloop.

=item $loop->B<leave> ()

Leave the mainloop, which was started with the enter() method.

=item $watcher = $loop->B<add_io_watcher> ( %options )

Add an I/O watcher. Options are passed as a hash of
key/value pairs. The following options are known:

=over 4

=item B<fh>

The filehandle to be watched.

=item B<cb>

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

=item B<desc>

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

=item B<poll>

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

=back

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

=item $loop->B<del_io_watcher> ( $watcher )

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

=item $timer = $loop->B<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:

=over 4

=item B<interval>

A time interval in seconds, may be fractional.

=item B<after>

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

=item B<cb>

The callback.

=item B<desc>

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

=back

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

=item $loop->B<del_timer> ( $timer )

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

=back

=head1 DIRECT USAGE IN YOUR SERVER

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.

=head1 AUTHORS

  Jörn Reder <joern at zyn dot de>

=head1 COPYRIGHT AND LICENSE

Copyright (C) 2002-2006 by Joern Reder, All Rights Reserved.

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

=cut