ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent/lib/AnyEvent.pm
(Generate patch)

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.312 by root, Mon Feb 15 18:02:35 2010 UTC vs.
Revision 1.325 by root, Thu May 20 23:56:04 2010 UTC

… …
7 7
8=head1 SYNOPSIS 8=head1 SYNOPSIS
9 9
10 use AnyEvent; 10 use AnyEvent;
11 11
12 # if you prefer function calls, look at the AE manpage for
13 # an alternative API.
14
12 # file descriptor readable 15 # file handle or descriptor readable
13 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... }); 16 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });
14 17
15 # one-shot or repeating timers 18 # one-shot or repeating timers
16 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... }); 19 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
17 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ... 20 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
… …
606eventually calls C<< -> send >>, and the "consumer side", which waits 609eventually calls C<< -> send >>, and the "consumer side", which waits
607for the send to occur. 610for the send to occur.
608 611
609Example: wait for a timer. 612Example: wait for a timer.
610 613
611 # wait till the result is ready 614 # condition: "wait till the timer is fired"
612 my $result_ready = AnyEvent->condvar; 615 my $timer_fired = AnyEvent->condvar;
613 616
614 # do something such as adding a timer 617 # create the timer - we could wait for, say
615 # or socket watcher the calls $result_ready->send 618 # a handle becomign ready, or even an
616 # when the "result" is ready. 619 # AnyEvent::HTTP request to finish, but
617 # in this case, we simply use a timer: 620 # in this case, we simply use a timer:
618 my $w = AnyEvent->timer ( 621 my $w = AnyEvent->timer (
619 after => 1, 622 after => 1,
620 cb => sub { $result_ready->send }, 623 cb => sub { $timer_fired->send },
621 ); 624 );
622 625
623 # this "blocks" (while handling events) till the callback 626 # this "blocks" (while handling events) till the callback
624 # calls ->send 627 # calls ->send
625 $result_ready->recv; 628 $timer_fired->recv;
626 629
627Example: wait for a timer, but take advantage of the fact that condition 630Example: wait for a timer, but take advantage of the fact that condition
628variables are also callable directly. 631variables are also callable directly.
629 632
630 my $done = AnyEvent->condvar; 633 my $done = AnyEvent->condvar;
… …
1054=head1 OTHER MODULES 1057=head1 OTHER MODULES
1055 1058
1056The following is a non-exhaustive list of additional modules that use 1059The following is a non-exhaustive list of additional modules that use
1057AnyEvent as a client and can therefore be mixed easily with other AnyEvent 1060AnyEvent as a client and can therefore be mixed easily with other AnyEvent
1058modules and other event loops in the same program. Some of the modules 1061modules and other event loops in the same program. Some of the modules
1059come with AnyEvent, most are available via CPAN. 1062come as part of AnyEvent, the others are available via CPAN.
1060 1063
1061=over 4 1064=over 4
1062 1065
1063=item L<AnyEvent::Util> 1066=item L<AnyEvent::Util>
1064 1067
… …
1079 1082
1080=item L<AnyEvent::DNS> 1083=item L<AnyEvent::DNS>
1081 1084
1082Provides rich asynchronous DNS resolver capabilities. 1085Provides rich asynchronous DNS resolver capabilities.
1083 1086
1087=item L<AnyEvent::HTTP>, L<AnyEvent::IRC>, L<AnyEvent::XMPP>, L<AnyEvent::GPSD>, L<AnyEvent::IGS>, L<AnyEvent::FCP>
1088
1089Implement event-based interfaces to the protocols of the same name (for
1090the curious, IGS is the International Go Server and FCP is the Freenet
1091Client Protocol).
1092
1093=item L<AnyEvent::Handle::UDP>
1094
1095Here be danger!
1096
1097As Pauli would put it, "Not only is it not right, it's not even wrong!" -
1098there are so many things wrong with AnyEvent::Handle::UDP, most notably
1099it's use of a stream-based API with a protocol that isn't streamable, that
1100the only way to improve it is to delete it.
1101
1102It features data corruption (but typically only under load) and general
1103confusion. On top, the author is not only clueless about UDP but also
1104fact-resistant - some gems of his understanding: "connect doesn't work
1105with UDP", "UDP packets are not IP packets", "UDP only has datagrams, not
1106packets", "I don't need to implement proper error checking as UDP doesn't
1107support error checking" and so on - he doesn't even understand what's
1108wrong with his module when it is explained to him.
1109
1084=item L<AnyEvent::HTTP> 1110=item L<AnyEvent::DBI>
1085 1111
1086A simple-to-use HTTP library that is capable of making a lot of concurrent 1112Executes L<DBI> requests asynchronously in a proxy process for you,
1087HTTP requests. 1113notifying you in an event-bnased way when the operation is finished.
1114
1115=item L<AnyEvent::AIO>
1116
1117Truly asynchronous (as opposed to non-blocking) I/O, should be in the
1118toolbox of every event programmer. AnyEvent::AIO transparently fuses
1119L<IO::AIO> and AnyEvent together, giving AnyEvent access to event-based
1120file I/O, and much more.
1088 1121
1089=item L<AnyEvent::HTTPD> 1122=item L<AnyEvent::HTTPD>
1090 1123
1091Provides a simple web application server framework. 1124A simple embedded webserver.
1092 1125
1093=item L<AnyEvent::FastPing> 1126=item L<AnyEvent::FastPing>
1094 1127
1095The fastest ping in the west. 1128The fastest ping in the west.
1096
1097=item L<AnyEvent::DBI>
1098
1099Executes L<DBI> requests asynchronously in a proxy process.
1100
1101=item L<AnyEvent::AIO>
1102
1103Truly asynchronous I/O, should be in the toolbox of every event
1104programmer. AnyEvent::AIO transparently fuses L<IO::AIO> and AnyEvent
1105together.
1106
1107=item L<AnyEvent::BDB>
1108
1109Truly asynchronous Berkeley DB access. AnyEvent::BDB transparently fuses
1110L<BDB> and AnyEvent together.
1111
1112=item L<AnyEvent::GPSD>
1113
1114A non-blocking interface to gpsd, a daemon delivering GPS information.
1115
1116=item L<AnyEvent::IRC>
1117
1118AnyEvent based IRC client module family (replacing the older Net::IRC3).
1119
1120=item L<AnyEvent::XMPP>
1121
1122AnyEvent based XMPP (Jabber protocol) module family (replacing the older
1123Net::XMPP2>.
1124
1125=item L<AnyEvent::IGS>
1126
1127A non-blocking interface to the Internet Go Server protocol (used by
1128L<App::IGS>).
1129
1130=item L<Net::FCP>
1131
1132AnyEvent-based implementation of the Freenet Client Protocol, birthplace
1133of AnyEvent.
1134
1135=item L<Event::ExecFlow>
1136
1137High level API for event-based execution flow control.
1138 1129
1139=item L<Coro> 1130=item L<Coro>
1140 1131
1141Has special support for AnyEvent via L<Coro::AnyEvent>. 1132Has special support for AnyEvent via L<Coro::AnyEvent>.
1142 1133
… …
1156 1147
1157BEGIN { AnyEvent::common_sense } 1148BEGIN { AnyEvent::common_sense }
1158 1149
1159use Carp (); 1150use Carp ();
1160 1151
1161our $VERSION = '5.24'; 1152our $VERSION = '5.261';
1162our $MODEL; 1153our $MODEL;
1163 1154
1164our $AUTOLOAD; 1155our $AUTOLOAD;
1165our @ISA; 1156our @ISA;
1166 1157
1167our @REGISTRY; 1158our @REGISTRY;
1168 1159
1169our $VERBOSE; 1160our $VERBOSE;
1170 1161
1171BEGIN { 1162BEGIN {
1172 eval "sub CYGWIN(){" . (($^O =~ /cygwin/i) *1) . "}"; 1163 require "AnyEvent/constants.pl";
1173 eval "sub WIN32 (){" . (($^O =~ /mswin32/i)*1) . "}"; 1164
1174 eval "sub TAINT (){" . (${^TAINT} *1) . "}"; 1165 eval "sub TAINT (){" . (${^TAINT}*1) . "}";
1175 1166
1176 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} 1167 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1177 if ${^TAINT}; 1168 if ${^TAINT};
1178 1169
1179 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1; 1170 $VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;
… …
1222our @post_detect; 1213our @post_detect;
1223 1214
1224sub post_detect(&) { 1215sub post_detect(&) {
1225 my ($cb) = @_; 1216 my ($cb) = @_;
1226 1217
1227 if ($MODEL) {
1228 $cb->();
1229
1230 undef
1231 } else {
1232 push @post_detect, $cb; 1218 push @post_detect, $cb;
1233 1219
1234 defined wantarray 1220 defined wantarray
1235 ? bless \$cb, "AnyEvent::Util::postdetect" 1221 ? bless \$cb, "AnyEvent::Util::postdetect"
1236 : () 1222 : ()
1237 }
1238} 1223}
1239 1224
1240sub AnyEvent::Util::postdetect::DESTROY { 1225sub AnyEvent::Util::postdetect::DESTROY {
1241 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1226 @post_detect = grep $_ != ${$_[0]}, @post_detect;
1242} 1227}
… …
1295 @models = (); # free probe data 1280 @models = (); # free probe data
1296 1281
1297 push @{"$MODEL\::ISA"}, "AnyEvent::Base"; 1282 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1298 unshift @ISA, $MODEL; 1283 unshift @ISA, $MODEL;
1299 1284
1285 # now nuke some methods that are overriden by the backend.
1286 # SUPER is not allowed.
1287 for (qw(time signal child idle)) {
1288 undef &{"AnyEvent::Base::$_"}
1289 if defined &{"$MODEL\::$_"};
1290 }
1291
1300 require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT}; 1292 require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1301 1293
1302 (shift @post_detect)->() while @post_detect; 1294 (shift @post_detect)->() while @post_detect;
1295
1296 *post_detect = sub(&) {
1297 shift->();
1298
1299 undef
1300 };
1303 1301
1304 $MODEL 1302 $MODEL
1305} 1303}
1306 1304
1307sub AUTOLOAD { 1305sub AUTOLOAD {
… …
1335 1333
1336=head1 SIMPLIFIED AE API 1334=head1 SIMPLIFIED AE API
1337 1335
1338Starting with version 5.0, AnyEvent officially supports a second, much 1336Starting with version 5.0, AnyEvent officially supports a second, much
1339simpler, API that is designed to reduce the calling, typing and memory 1337simpler, API that is designed to reduce the calling, typing and memory
1340overhead. 1338overhead by using function call syntax and a fixed number of parameters.
1341 1339
1342See the L<AE> manpage for details. 1340See the L<AE> manpage for details.
1343 1341
1344=cut 1342=cut
1345 1343
1346package AE; 1344package AE;
1347 1345
1348our $VERSION = $AnyEvent::VERSION; 1346our $VERSION = $AnyEvent::VERSION;
1347
1348# fall back to the main API by default - backends and AnyEvent::Base
1349# implementations can overwrite these.
1349 1350
1350sub io($$$) { 1351sub io($$$) {
1351 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2]) 1352 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])
1352} 1353}
1353 1354
… …
1385 1386
1386package AnyEvent::Base; 1387package AnyEvent::Base;
1387 1388
1388# default implementations for many methods 1389# default implementations for many methods
1389 1390
1390sub _time() { 1391sub time {
1391 eval q{ # poor man's autoloading 1392 eval q{ # poor man's autoloading {}
1392 # probe for availability of Time::HiRes 1393 # probe for availability of Time::HiRes
1393 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1394 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1394 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8; 1395 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1395 *_time = \&Time::HiRes::time; 1396 *AE::time = \&Time::HiRes::time;
1396 # if (eval "use POSIX (); (POSIX::times())... 1397 # if (eval "use POSIX (); (POSIX::times())...
1397 } else { 1398 } else {
1398 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE; 1399 warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;
1399 *_time = sub (){ time }; # epic fail 1400 *AE::time = sub (){ time }; # epic fail
1400 } 1401 }
1402
1403 *time = sub { AE::time }; # different prototypes
1401 }; 1404 };
1402 die if $@; 1405 die if $@;
1403 1406
1404 &_time 1407 &time
1405} 1408}
1406 1409
1407sub time { _time } 1410*now = \&time;
1408sub now { _time } 1411
1409sub now_update { } 1412sub now_update { }
1410 1413
1411# default implementation for ->condvar 1414# default implementation for ->condvar
1412 1415
1413sub condvar { 1416sub condvar {
1417 eval q{ # poor man's autoloading {}
1418 *condvar = sub {
1414 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar" 1419 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1420 };
1421
1422 *AE::cv = sub (;&) {
1423 bless { @_ ? (_ae_cb => shift) : () }, "AnyEvent::CondVar"
1424 };
1425 };
1426 die if $@;
1427
1428 &condvar
1415} 1429}
1416 1430
1417# default implementation for ->signal 1431# default implementation for ->signal
1418 1432
1419our $HAVE_ASYNC_INTERRUPT; 1433our $HAVE_ASYNC_INTERRUPT;
… …
1449 undef $SIG_TW 1463 undef $SIG_TW
1450 unless --$SIG_COUNT; 1464 unless --$SIG_COUNT;
1451} 1465}
1452 1466
1453our $_sig_name_init; $_sig_name_init = sub { 1467our $_sig_name_init; $_sig_name_init = sub {
1454 eval q{ # poor man's autoloading 1468 eval q{ # poor man's autoloading {}
1455 undef $_sig_name_init; 1469 undef $_sig_name_init;
1456 1470
1457 if (_have_async_interrupt) { 1471 if (_have_async_interrupt) {
1458 *sig2num = \&Async::Interrupt::sig2num; 1472 *sig2num = \&Async::Interrupt::sig2num;
1459 *sig2name = \&Async::Interrupt::sig2name; 1473 *sig2name = \&Async::Interrupt::sig2name;
… …
1491 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec; 1505 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1492 1506
1493 } else { 1507 } else {
1494 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8; 1508 warn "AnyEvent: using emulated perl signal handling with latency timer.\n" if $VERBOSE >= 8;
1495 1509
1496 require Fcntl;
1497
1498 if (AnyEvent::WIN32) { 1510 if (AnyEvent::WIN32) {
1499 require AnyEvent::Util; 1511 require AnyEvent::Util;
1500 1512
1501 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe (); 1513 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1502 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R; 1514 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R, 1) if $SIGPIPE_R;
1503 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case 1515 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W, 1) if $SIGPIPE_W; # just in case
1504 } else { 1516 } else {
1505 pipe $SIGPIPE_R, $SIGPIPE_W; 1517 pipe $SIGPIPE_R, $SIGPIPE_W;
1506 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1518 fcntl $SIGPIPE_R, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_R;
1507 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case 1519 fcntl $SIGPIPE_W, AnyEvent::F_SETFL, AnyEvent::O_NONBLOCK if $SIGPIPE_W; # just in case
1508 1520
1509 # not strictly required, as $^F is normally 2, but let's make sure... 1521 # not strictly required, as $^F is normally 2, but let's make sure...
1510 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC; 1522 fcntl $SIGPIPE_R, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1511 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC; 1523 fcntl $SIGPIPE_W, AnyEvent::F_SETFD, AnyEvent::FD_CLOEXEC;
1512 } 1524 }
1513 1525
1514 $SIGPIPE_R 1526 $SIGPIPE_R
1515 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1527 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1516 1528
1517 $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec; 1529 $SIG_IO = AE::io $SIGPIPE_R, 0, \&_signal_exec;
1518 } 1530 }
1519 1531
1520 *signal = sub { 1532 *signal = $HAVE_ASYNC_INTERRUPT
1533 ? sub {
1521 my (undef, %arg) = @_; 1534 my (undef, %arg) = @_;
1522 1535
1523 my $signal = uc $arg{signal}
1524 or Carp::croak "required option 'signal' is missing";
1525
1526 if ($HAVE_ASYNC_INTERRUPT) {
1527 # async::interrupt 1536 # async::interrupt
1528
1529 $signal = sig2num $signal; 1537 my $signal = sig2num $arg{signal};
1530 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1538 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1531 1539
1532 $SIG_ASY{$signal} ||= new Async::Interrupt 1540 $SIG_ASY{$signal} ||= new Async::Interrupt
1533 cb => sub { undef $SIG_EV{$signal} }, 1541 cb => sub { undef $SIG_EV{$signal} },
1534 signal => $signal, 1542 signal => $signal,
1535 pipe => [$SIGPIPE_R->filenos], 1543 pipe => [$SIGPIPE_R->filenos],
1536 pipe_autodrain => 0, 1544 pipe_autodrain => 0,
1537 ; 1545 ;
1538 1546
1539 } else { 1547 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1548 }
1549 : sub {
1550 my (undef, %arg) = @_;
1551
1540 # pure perl 1552 # pure perl
1541
1542 # AE::Util has been loaded in signal
1543 $signal = sig2name $signal; 1553 my $signal = sig2name $arg{signal};
1544 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1554 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1545 1555
1546 $SIG{$signal} ||= sub { 1556 $SIG{$signal} ||= sub {
1547 local $!; 1557 local $!;
1548 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1558 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1549 undef $SIG_EV{$signal}; 1559 undef $SIG_EV{$signal};
1550 }; 1560 };
1551 1561
1552 # can't do signal processing without introducing races in pure perl, 1562 # can't do signal processing without introducing races in pure perl,
1553 # so limit the signal latency. 1563 # so limit the signal latency.
1554 _sig_add; 1564 _sig_add;
1555 }
1556 1565
1557 bless [$signal, $arg{cb}], "AnyEvent::Base::signal" 1566 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1567 }
1558 }; 1568 ;
1559 1569
1560 *AnyEvent::Base::signal::DESTROY = sub { 1570 *AnyEvent::Base::signal::DESTROY = sub {
1561 my ($signal, $cb) = @{$_[0]}; 1571 my ($signal, $cb) = @{$_[0]};
1562 1572
1563 _sig_del; 1573 _sig_del;
… …
2059 2069
2060The actual code goes further and collects all errors (C<die>s, exceptions) 2070The actual code goes further and collects all errors (C<die>s, exceptions)
2061that occurred during request processing. The C<result> method detects 2071that occurred during request processing. The C<result> method detects
2062whether an exception as thrown (it is stored inside the $txn object) 2072whether an exception as thrown (it is stored inside the $txn object)
2063and just throws the exception, which means connection errors and other 2073and just throws the exception, which means connection errors and other
2064problems get reported tot he code that tries to use the result, not in a 2074problems get reported to the code that tries to use the result, not in a
2065random callback. 2075random callback.
2066 2076
2067All of this enables the following usage styles: 2077All of this enables the following usage styles:
2068 2078
20691. Blocking: 20791. Blocking:
… …
2526automatic timer adjustments even when no monotonic clock is available, 2536automatic timer adjustments even when no monotonic clock is available,
2527can take avdantage of advanced kernel interfaces such as C<epoll> and 2537can take avdantage of advanced kernel interfaces such as C<epoll> and
2528C<kqueue>, and is the fastest backend I<by far>. You can even embed 2538C<kqueue>, and is the fastest backend I<by far>. You can even embed
2529L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>). 2539L<Glib>/L<Gtk2> in it (or vice versa, see L<EV::Glib> and L<Glib::EV>).
2530 2540
2541If you only use backends that rely on another event loop (e.g. C<Tk>),
2542then this module will do nothing for you.
2543
2531=item L<Guard> 2544=item L<Guard>
2532 2545
2533The guard module, when used, will be used to implement 2546The guard module, when used, will be used to implement
2534C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a 2547C<AnyEvent::Util::guard>. This speeds up guards considerably (and uses a
2535lot less memory), but otherwise doesn't affect guard operation much. It is 2548lot less memory), but otherwise doesn't affect guard operation much. It is
2536purely used for performance. 2549purely used for performance.
2537 2550
2538=item L<JSON> and L<JSON::XS> 2551=item L<JSON> and L<JSON::XS>
2539 2552
2540One of these modules is required when you want to read or write JSON data 2553One of these modules is required when you want to read or write JSON data
2541via L<AnyEvent::Handle>. It is also written in pure-perl, but can take 2554via L<AnyEvent::Handle>. L<JSON> is also written in pure-perl, but can take
2542advantage of the ultra-high-speed L<JSON::XS> module when it is installed. 2555advantage of the ultra-high-speed L<JSON::XS> module when it is installed.
2543
2544In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is
2545installed.
2546 2556
2547=item L<Net::SSLeay> 2557=item L<Net::SSLeay>
2548 2558
2549Implementing TLS/SSL in Perl is certainly interesting, but not very 2559Implementing TLS/SSL in Perl is certainly interesting, but not very
2550worthwhile: If this module is installed, then L<AnyEvent::Handle> (with 2560worthwhile: If this module is installed, then L<AnyEvent::Handle> (with

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines