Coro/Event/Event.pm

=head1 NAME

Coro::Event - do events the coro-way

=head1 SYNOPSIS

 use Coro;
 use Coro::Event;

 sub keyboard : Coro {
    my $w = Coro::Event->io(fd => \*STDIN, poll => 'r');
    while() {
       print "cmd> ";
       my $ev = $w->next; my $cmd = <STDIN>;
       unloop unless $cmd ne "";
       print "data> ";
       my $ev = $w->next; my $data = <STDIN>;
    }
 }

 loop;

=head1 DESCRIPTION

This module enables you to create programs using the powerful Event model
(and module), while retaining the linear style known from simple or
threaded programs.

This module provides a method and a function for every watcher type
(I<flavour>) (see L<Event>). The only difference between these and the
watcher constructors from Event is that you do not specify a callback
function - it will be managed by this module.

Your application should just create all necessary coroutines and then call
Coro::Event::loop.

Please note that even programs or modules (such as
L<Coro::Handle|Coro::Handle>) that use "traditional"
event-based/continuation style will run more efficient with this module
then when using only Event.

=over 4

=cut

package Coro::Event;

BEGIN { eval { require warnings } && warnings->unimport ("uninitialized") }

use Carp;
no warnings;

use Coro;
use Event qw(loop unloop); # we are re-exporting this, cooool!

use XSLoader;

use base Exporter::;

our @EXPORT = qw(loop unloop sweep reschedule);

BEGIN {
   our $VERSION = 1.9;

   local $^W = 0; # avoid redefine warning for Coro::ready;
   XSLoader::load __PACKAGE__, $VERSION;
}

=item $w = Coro::Event->flavour(args...)

Create and return a watcher of the given type.

Examples:

  my $reader = Coro::Event->io(fd => $filehandle, poll => 'r');
  $reader->next;

=cut

=item $w->next

Return the next event of the event queue of the watcher.

=cut

=item do_flavour(args...)

Create a watcher of the given type and immediately call it's next
method. This is less efficient then calling the constructor once and the
next method often, but it does save typing sometimes.

=cut

for my $flavour (qw(idle var timer io signal)) {
   push @EXPORT, "do_$flavour";
   my $new = \&{"Event::$flavour"};
   my $class = "Coro::Event::$flavour";
   my $type = $flavour eq "io" ? 1 : 0;
   @{"${class}::ISA"} = (Coro::Event::, "Event::$flavour");
   my $coronew = sub {
      # how does one do method-call-by-name?
      # my $w = $class->SUPER::$flavour(@_);

      shift eq Coro::Event::
         or croak "event constructor \"Coro::Event->$flavour\" must be called as a static method";

      my $w = $new->($class,
            desc => $flavour,
            @_,
            parked => 1,
      );
      _install_std_cb($w, $type);
      bless $w, $class; # reblessing due to broken Event
   };
   *{    $flavour } = $coronew;
   *{"do_$flavour"} = sub {
      unshift @_, Coro::Event::;
      my $e = (&$coronew)->next;
      $e->cancel; # $e === $e->w
      $e;
   };
}

# double calls to avoid stack-cloning ;()
# is about 10% slower, though.
sub next($) {
   &Coro::schedule if &_next; $_[0];
}

sub Coro::Event::w    { $_[0] }
sub Coro::Event::prio { $_[0]{Coro::Event}[3] }
sub Coro::Event::hits { $_[0]{Coro::Event}[4] }
sub Coro::Event::got  { $_[0]{Coro::Event}[5] }

=item sweep

Similar to Event::one_event and Event::sweep: The idle task is called once
(this has the effect of jumping back into the Event loop once to serve new
events).

The reason this function exists is that you sometimes want to serve events
while doing other work. Calling C<Coro::cede> does not work because
C<cede> implies that the current coroutine is runnable and does not call
into the Event dispatcher.

=cut

sub sweep {
   Event::one_event(0); # for now
}

=item $result = loop([$timeout])

This is the version of C<loop> you should use instead of C<Event::loop>
when using this module - it will ensure correct scheduling in the presence
of events.

=item unloop([$result])

Same as Event::unloop (provided here for your convinience only).

=cut

$Coro::idle = new Coro sub {
   while () {
      Event::one_event; # inefficient
      Coro::schedule;
   }
};

# provide hooks for Coro::Timer

package Coro::Timer;

unless ($override) {
   $override = 1;
   *_new_timer = sub {
      Event->timer(at => $_[0], cb => $_[1]);
   };
}

1;

=back

=head1 AUTHOR

 Marc Lehmann <schmorp@schmorp.de>
 http://home.schmorp.de/

=cut

Revision:	1.39
Committed:	Fri Nov 24 00:09:08 2006 UTC (17 years, 7 months ago) by root
Branch:	MAIN
Changes since 1.38:	+1 -1 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	=head1 NAME
2
3			Coro::Event - do events the coro-way
4
5			=head1 SYNOPSIS
6
7			use Coro;
8			use Coro::Event;
9
10			sub keyboard : Coro {
11	pcg	1.21	my $w = Coro::Event->io(fd => \*STDIN, poll => 'r');
12	root	1.1	while() {
13			print "cmd> ";
14			my $ev = $w->next; my $cmd = <STDIN>;
15			unloop unless $cmd ne "";
16			print "data> ";
17			my $ev = $w->next; my $data = <STDIN>;
18			}
19			}
20
21	root	1.8	loop;
22	root	1.1
23			=head1 DESCRIPTION
24
25			This module enables you to create programs using the powerful Event model
26			(and module), while retaining the linear style known from simple or
27			threaded programs.
28
29			This module provides a method and a function for every watcher type
30			(I<flavour>) (see L<Event>). The only difference between these and the
31			watcher constructors from Event is that you do not specify a callback
32			function - it will be managed by this module.
33
34			Your application should just create all necessary coroutines and then call
35	root	1.12	Coro::Event::loop.
36	root	1.1
37	root	1.37	Please note that even programs or modules (such as
38			L<Coro::Handle\|Coro::Handle>) that use "traditional"
39			event-based/continuation style will run more efficient with this module
40			then when using only Event.
41
42	root	1.1	=over 4
43
44			=cut
45
46			package Coro::Event;
47
48	pcg	1.18	BEGIN { eval { require warnings } && warnings->unimport ("uninitialized") }
49	root	1.1
50			use Carp;
51	root	1.30	no warnings;
52	root	1.1
53			use Coro;
54	root	1.8	use Event qw(loop unloop); # we are re-exporting this, cooool!
55	root	1.1
56	root	1.30	use XSLoader;
57	root	1.1
58	root	1.30	use base Exporter::;
59
60			our @EXPORT = qw(loop unloop sweep reschedule);
61	root	1.1
62	root	1.2	BEGIN {
63	root	1.35	our $VERSION = 1.9;
64	root	1.2
65	root	1.13	local $^W = 0; # avoid redefine warning for Coro::ready;
66	root	1.30	XSLoader::load __PACKAGE__, $VERSION;
67	root	1.2	}
68	root	1.1
69			=item $w = Coro::Event->flavour(args...)
70
71			Create and return a watcher of the given type.
72
73			Examples:
74
75			my $reader = Coro::Event->io(fd => $filehandle, poll => 'r');
76			$reader->next;
77
78			=cut
79
80			=item $w->next
81
82			Return the next event of the event queue of the watcher.
83
84			=cut
85
86			=item do_flavour(args...)
87
88			Create a watcher of the given type and immediately call it's next
89			method. This is less efficient then calling the constructor once and the
90			next method often, but it does save typing sometimes.
91
92			=cut
93
94			for my $flavour (qw(idle var timer io signal)) {
95			push @EXPORT, "do_$flavour";
96			my $new = \&{"Event::$flavour"};
97			my $class = "Coro::Event::$flavour";
98	root	1.2	my $type = $flavour eq "io" ? 1 : 0;
99	root	1.1	@{"${class}::ISA"} = (Coro::Event::, "Event::$flavour");
100			my $coronew = sub {
101			# how does one do method-call-by-name?
102			# my $w = $class->SUPER::$flavour(@_);
103
104	root	1.10	shift eq Coro::Event::
105	root	1.1	or croak "event constructor \"Coro::Event->$flavour\" must be called as a static method";
106
107	root	1.10	my $w = $new->($class,
108	root	1.1	desc => $flavour,
109			@_,
110	root	1.2	parked => 1,
111	root	1.1	);
112	root	1.2	_install_std_cb($w, $type);
113	root	1.1	bless $w, $class; # reblessing due to broken Event
114			};
115			*{ $flavour } = $coronew;
116			*{"do_$flavour"} = sub {
117			unshift @_, Coro::Event::;
118			my $e = (&$coronew)->next;
119	pcg	1.20	$e->cancel; # $e === $e->w
120	root	1.1	$e;
121			};
122			}
123
124	root	1.2	# double calls to avoid stack-cloning ;()
125	root	1.3	# is about 10% slower, though.
126	root	1.2	sub next($) {
127	root	1.3	&Coro::schedule if &_next; $_[0];
128	root	1.1	}
129	root	1.2
130	root	1.4	sub Coro::Event::w { $_[0] }
131	root	1.5	sub Coro::Event::prio { $_[0]{Coro::Event}[3] }
132			sub Coro::Event::hits { $_[0]{Coro::Event}[4] }
133			sub Coro::Event::got { $_[0]{Coro::Event}[5] }
134	root	1.1
135			=item sweep
136
137			Similar to Event::one_event and Event::sweep: The idle task is called once
138			(this has the effect of jumping back into the Event loop once to serve new
139			events).
140
141			The reason this function exists is that you sometimes want to serve events
142			while doing other work. Calling C<Coro::cede> does not work because
143			C<cede> implies that the current coroutine is runnable and does not call
144			into the Event dispatcher.
145
146			=cut
147
148			sub sweep {
149	root	1.7	Event::one_event(0); # for now
150	root	1.1	}
151
152			=item $result = loop([$timeout])
153
154			This is the version of C<loop> you should use instead of C<Event::loop>
155			when using this module - it will ensure correct scheduling in the presence
156			of events.
157
158			=item unloop([$result])
159
160			Same as Event::unloop (provided here for your convinience only).
161
162			=cut
163
164			$Coro::idle = new Coro sub {
165			while () {
166	root	1.39	Event::one_event; # inefficient
167	root	1.38	Coro::schedule;
168	root	1.1	}
169			};
170
171	root	1.9	# provide hooks for Coro::Timer
172
173			package Coro::Timer;
174
175			unless ($override) {
176			$override = 1;
177			*_new_timer = sub {
178			Event->timer(at => $_[0], cb => $_[1]);
179			};
180			}
181
182	root	1.1	1;
183
184	root	1.36	=back
185
186	root	1.1	=head1 AUTHOR
187
188	root	1.27	Marc Lehmann <schmorp@schmorp.de>
189	root	1.25	http://home.schmorp.de/
190	root	1.1
191			=cut
192