view release on metacpan or search on metacpan
lib/AnyEvent/DBD/Pg.pm view on Meta::CPAN
use 5.008008; # don't use old crap without utf8
use common::sense 3;m{
use strict;
use warnings;
}x;
use Scalar::Util 'weaken';
use Carp;
use DBI;
use DBD::Pg ':async';
use AE 5;
use Time::HiRes 'time';
lib/AnyEvent/DBD/Pg.pm view on Meta::CPAN
my $counter = ++$self->{querynum};
warn "prepare call <$query>( @_ ), async status = ".$self->{db}->{pg_async_status} if $self->{debug} > 2;
$self->{current} = [$query,@_];
$self->{current_start} = time();
weaken $self;
$self or return;
my ($st,$w,$t,$check);
my @watchers;
push @watchers, sub {
$self and $st or warn("no self"), @watchers = (), return 1;
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
" return \$_[0]->{%s} = do { my \$self = \$_[0]; %s }\n" .
" unless \$#_ > 0 or defined \$_[0]->{%s};\n",
weak_init =>
" return do {\n" .
" \$_[0]->{%s} = do { my \$self = \$_[0]; %s };\n" .
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n" .
" \$_[0]->{%s};\n" .
" } unless \$#_ > 0 or defined \$_[0]->{%s};\n",
return_if_get =>
" return \$_[0]->{%s} unless \$#_ > 0;\n",
set =>
" \$_[0]->{%s} = \$_[1];\n",
weaken =>
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n",
sub_end =>
" return \$_[0]->{%s};\n}\n",
);
sub field {
inc/Spiffy.pm view on Meta::CPAN
local *paired_arguments = sub { (qw(-package -init)) };
Spiffy->parse_arguments(@_);
};
my ($field, $default) = @values;
$package = $args->{-package} if defined $args->{-package};
die "Cannot have a default for a weakened field ($field)"
if defined $default && $args->{-weak};
return if defined &{"${package}::$field"};
require Scalar::Util if $args->{-weak};
my $default_string =
( ref($default) eq 'ARRAY' and not @$default )
inc/Spiffy.pm view on Meta::CPAN
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
$code .= sprintf $code{weaken}, $field, $field
if $args->{-weak};
$code .= sprintf $code{sub_end}, $field;
my $sub = eval $code;
die $@ if $@;
view release on metacpan or search on metacpan
lib/AnyEvent/DBI/MySQL.pm view on Meta::CPAN
## no critic(ProhibitMultiplePackages Capitalization ProhibitNoWarnings)
use base qw( DBI );
use AnyEvent;
use Scalar::Util qw( weaken );
my @DATA;
my @NEXT_ID = ();
my $NEXT_ID = 0;
my $PRIVATE = 'private_' . __PACKAGE__;
lib/AnyEvent/DBI/MySQL.pm view on Meta::CPAN
$attr->{RootClass} = $class;
$attr->{$PRIVATE} = $id;
my $dbh = DBI->connect_cached($dsn, $user, $pass, $attr);
return if !$dbh;
# weaken cached $dbh to have DESTROY called when user stop using it
my $cache = $dbh->{Driver}{CachedKids};
for (grep {$cache->{$_} && $cache->{$_} == $dbh} keys %{$cache}) {
weaken($cache->{$_});
}
weaken(my $weakdbh = $dbh);
my $io_cb; $io_cb = sub {
local $SIG{__WARN__} = sub { (my $msg=shift)=~s/ at .*//ms; warn "$msg\n" };
my $data = $DATA[$id];
my $cb = delete $data->{cb};
my $h = delete $data->{h};
lib/AnyEvent/DBI/MySQL.pm view on Meta::CPAN
package AnyEvent::DBI::MySQL::db;
use base qw( DBI::db );
use Carp;
use Scalar::Util qw( weaken );
my $GLOBAL_DESTRUCT = 0;
END { $GLOBAL_DESTRUCT = 1; }
sub DESTROY {
lib/AnyEvent/DBI/MySQL.pm view on Meta::CPAN
push @NEXT_ID, $dbh->{$PRIVATE};
if (!$dbh->{Active}) {
$dbh->SUPER::DESTROY();
}
else {
# un-weaken cached $dbh to keep it for next connect_cached()
my $cache = $dbh->{Driver}{CachedKids};
for (grep {$cache->{$_} && $cache->{$_} == $dbh} keys %{$cache}) {
$cache->{$_} = $dbh;
}
}
lib/AnyEvent/DBI/MySQL.pm view on Meta::CPAN
if ($data->{cb}) {
croak q{can't make more than one asynchronous query simultaneously};
}
$data->{cb} = pop @args;
$data->{h} = $dbh;
weaken($data->{h});
$args[1] //= {};
$args[1]->{async} //= 1;
if (!$args[1]->{async}) {
my $cb = delete $data->{cb};
my $h = delete $data->{h};
lib/AnyEvent/DBI/MySQL.pm view on Meta::CPAN
my $cb = $args[-1];
# The select*() functions should be called twice:
# - first time they'll do only prepare() and execute()
# * we should return false from execute() to interrupt them
# after execute(), before they'll start fetching data
# * we shouldn't weaken {h} because their $sth will be
# destroyed when they will be interrupted
# - second time they'll do only data fetching:
# * they should get ready $sth instead of query param,
# so they'll skip prepare()
# * this $sth should be AnyEvent::DBI::MySQL::st::ready,
# so they'll skip execute()
$data->{call_again} = [@args[1 .. $#args-1]];
weaken($dbh);
$args[-1] = sub {
my (undef, $sth, $args) = @_;
return if !$dbh;
if ($dbh->err) {
$cb->();
lib/AnyEvent/DBI/MySQL.pm view on Meta::CPAN
package AnyEvent::DBI::MySQL::st;
use base qw( DBI::st );
use Carp;
use Scalar::Util qw( weaken );
sub execute {
my ($sth, @args) = @_;
local $SIG{__WARN__} = sub { (my $msg=shift)=~s/ at .*//ms; carp $msg };
my $data = $DATA[ $sth->{$PRIVATE} ];
view release on metacpan or search on metacpan
# we don't rely on the callback, because we use our own
# socketpair, for better or worse.
$fork->run ("AnyEvent::DBI::Slave::serve", sub { });
{
Convert::Scalar::weaken (my $self = $self);
my $cbor = new CBOR::XS;
$self->{rw} = AE::io $client, 0, sub {
my $len = Convert::Scalar::extend_read $client, $rbuf, 65536;
Executes the given SQL statement with placeholders replaced by
C<@args>. The statement will be prepared and cached on the server side, so
using placeholders is extremely important.
The callback will be called with a weakened AnyEvent::DBI object as the
first argument and the result of C<fetchall_arrayref> as (or C<undef>
if the statement wasn't a select statement) as the second argument.
Third argument is the return value from the C<< DBI->execute >> method
call.
view release on metacpan or search on metacpan
lib/AnyEvent/Emitter.pm view on Meta::CPAN
package AnyEvent::Emitter;
use strict;
use Scalar::Util qw(blessed weaken);
our $VERSION = 0.02;
use constant DEBUG => $ENV{EMITTER_DEBUG} || 0;
lib/AnyEvent/Emitter.pm view on Meta::CPAN
sub on { push @{$_[0]{events}{$_[1]}}, $_[2] and return $_[2] }
sub once {
my ($self, $name, $cb) = @_;
weaken $self;
my $wrapper;
$wrapper = sub {
$self->unsubscribe($name => $wrapper);
$cb->(@_);
};
$self->on($name => $wrapper);
weaken $wrapper;
return $wrapper;
}
sub subscribers { shift->{events}{shift()} || [] }
view release on metacpan or search on metacpan
lib/AnyEvent/eris/Client.pm view on Meta::CPAN
# in second thought, this should just be removed because
# it's meant for internal manual buffering, which we don't need
$block
and AE::log fatal => 'Block option not supported';
Scalar::Util::weaken( my $inner_self = $self );
$self->{'_client'} ||= tcp_connect $addr, $port, sub {
my ($fh) = @_
or AE::log fatal => "Connect failed: $!";
view release on metacpan or search on metacpan
lib/AnyEvent/FCGI.pm view on Meta::CPAN
use strict;
use warnings;
our $VERSION = '0.04';
use Scalar::Util qw/weaken refaddr/;
use AnyEvent;
use AnyEvent::Socket;
use AnyEvent::Handle;
use AnyEvent::FCGI::Connection;
lib/AnyEvent/FCGI.pm view on Meta::CPAN
connections => {},
on_request_cb => $params{on_request},
}, $class;
my $fcgi = $self;
weaken($fcgi);
$params{socket} ||= $params{unix};
$self->{server} = tcp_server(
$params{socket} ? 'unix/' : $params{host},
view release on metacpan or search on metacpan
prefix => "..:aefcpid:$rand:",
idseq => "a0",
}, $class;
{
Scalar::Util::weaken (my $self = $self);
$self->{kw} = AE::timer $self->{keepalive}, $self->{keepalive}, sub {
$self->{hdl}->push_write ("\n");
};
on_error => sub {
$self->fatal ($_[2]);
},
;
Scalar::Util::weaken ($self->{hdl}{fcp} = $self);
}
$self->send_msg (client_hello =>
name => $self->{name},
expected_version => "2.0",
($ok, $err) = @$ok;
} elsif (UNIVERSAL::isa $ok, AnyEvent::CondVar::) {
$err = sub { $ok->croak ($_[0]{extra_description}) };
} else {
my $bt = Carp::longmess "AnyEvent::FCP request $name";
Scalar::Util::weaken (my $self = $_[0]);
my $args = [@_]; shift @$args;
$err = sub {
if ($self->{on_failure}) {
$self->{on_failure}($self, $name, $args, $bt, $_[0]);
} else {
view release on metacpan or search on metacpan
lib/AnyEvent/Feed.pm view on Meta::CPAN
use Encode;
use XML::Feed;
use MIME::Base64;
use AnyEvent::HTTP;
use Digest::SHA1 qw/sha1_base64/;
use Scalar::Util qw/weaken/;
our $VERSION = '0.3';
=head1 NAME
lib/AnyEvent/Feed.pm view on Meta::CPAN
unless (defined $self->{on_fetch}) {
croak "no 'on_fetch' callback given!";
}
my $wself = $self;
weaken $wself;
$self->{timer_cb} = sub {
$wself->fetch (sub {
my ($self, $e, $f, $err) = @_;
view release on metacpan or search on metacpan
lib/AnyEvent/Filesys/Notify/Role/Inotify2.pm view on Meta::CPAN
use Carp;
use Path::Iterator::Rule;
our $VERSION = '1.23';
# use Scalar::Util qw(weaken); # Attempt to address RT#57104, but alas...
sub _init {
my $self = shift;
my $inotify = Linux::Inotify2->new()
lib/AnyEvent/Filesys/Notify/Role/Inotify2.pm view on Meta::CPAN
# Need to add all the subdirs to the watch list, this will catch
# modifications to files too.
my $old_fs = $self->_old_fs;
my @dirs = grep { $old_fs->{$_}->{is_dir} } keys %$old_fs;
# weaken $self; # Attempt to address RT#57104, but alas...
for my $dir (@dirs) {
$inotify->watch(
$dir,
IN_MODIFY | IN_CREATE | IN_DELETE | IN_DELETE_SELF |
view release on metacpan or search on metacpan
lib/AnyEvent/Filesys/Watcher/FSEvents.pm view on Meta::CPAN
our $VERSION = 'v0.1.1'; # VERSION
use AnyEvent;
use Mac::FSEvents;
use Scalar::Util qw(weaken);
use Config;
use base qw(AnyEvent::Filesys::Watcher);
# Needed for counting unset bits.
lib/AnyEvent/Filesys/Watcher/FSEvents.pm view on Meta::CPAN
my $watcher = AE::io $self->{__mac_fh}, 0, sub {
if (my @raw_events = $fs_monitor->read_events) {
$alter_ego->_processEvents(@raw_events);
}
};
weaken $alter_ego;
$self->_watcher($watcher);
return $self;
}
view release on metacpan or search on metacpan
;
++$nidle;
Array::Heap::push_heap_idx @pool, $proc;
Scalar::Util::weaken $proc;
};
$stop_worker = sub {
my $proc = shift;
view release on metacpan or search on metacpan
lib/AnyEvent/ForkManager.pm view on Meta::CPAN
use warnings;
our $VERSION = '0.07';
use AnyEvent;
use Scalar::Util qw/weaken/;
use POSIX qw/WNOHANG/;
use Time::HiRes ();
use Class::Accessor::Lite 0.04 (
ro => [
lib/AnyEvent/ForkManager.pm view on Meta::CPAN
}
sub _create_callback {
my($self, @args) = @_;
weaken($self);
return sub {
my ($pid, $status) = @_;
delete $self->running_worker->{$pid};
delete $self->process_cb->{$pid};
$self->_run_cb('on_finish' => $pid, $status, @args);
lib/AnyEvent/ForkManager.pm view on Meta::CPAN
else {
die 'cannot call.' if $self->wait_async;
my $super = $self->on_finish;
weaken($self);
$self->on_finish(
sub {
$super->(@_);
if ($self->num_workers == 0 and $self->num_queues == 0) {
$self->$cb;
view release on metacpan or search on metacpan
lib/AnyEvent/ForkObject.pm view on Meta::CPAN
use Carp;
use AnyEvent;
use AnyEvent::Util;
use AnyEvent::Handle;
use Scalar::Util qw(weaken blessed reftype);
use POSIX;
use IO::Handle;
use AnyEvent::Serialize qw(:all);
use AnyEvent::Tools qw(mutex);
use Devel::GlobalDestruction;
lib/AnyEvent/ForkObject.pm view on Meta::CPAN
# parent
$self->{mutex} = mutex;
close $s2;
fh_nonblocking $s1, 1;
{
weaken(my $self = $self);
$self->{handle} = new AnyEvent::Handle
fh => $s1,
on_error => sub {
return unless $self;
return if $self->{destroyed};
lib/AnyEvent/ForkObject.pm view on Meta::CPAN
my $args = $opts{args} || [];
my $wantarray = $opts{wantarray};
my $require = $opts{require};
$wantarray = 0 unless exists $opts{wantarray};
weaken $self;
$self->{mutex}->lock(sub {
my ($guard) = @_;
return unless $self;
return if $self->{destroyed};
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
" return \$_[0]->{%s} = do { my \$self = \$_[0]; %s }\n" .
" unless \$#_ > 0 or defined \$_[0]->{%s};\n",
weak_init =>
" return do {\n" .
" \$_[0]->{%s} = do { my \$self = \$_[0]; %s };\n" .
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n" .
" \$_[0]->{%s};\n" .
" } unless \$#_ > 0 or defined \$_[0]->{%s};\n",
return_if_get =>
" return \$_[0]->{%s} unless \$#_ > 0;\n",
set =>
" \$_[0]->{%s} = \$_[1];\n",
weaken =>
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n",
sub_end =>
" return \$_[0]->{%s};\n}\n",
);
sub field {
inc/Spiffy.pm view on Meta::CPAN
local *paired_arguments = sub { (qw(-package -init)) };
Spiffy->parse_arguments(@_);
};
my ($field, $default) = @values;
$package = $args->{-package} if defined $args->{-package};
die "Cannot have a default for a weakened field ($field)"
if defined $default && $args->{-weak};
return if defined &{"${package}::$field"};
require Scalar::Util if $args->{-weak};
my $default_string =
( ref($default) eq 'ARRAY' and not @$default )
inc/Spiffy.pm view on Meta::CPAN
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
$code .= sprintf $code{weaken}, $field, $field
if $args->{-weak};
$code .= sprintf $code{sub_end}, $field;
my $sub = eval $code;
die $@ if $@;
view release on metacpan or search on metacpan
}
AnyEvent::Util::fh_nonblocking $self->{fh}, 1;
{
Scalar::Util::weaken (my $self = $self);
$self->{rw} = AE::io $self->{fh}, 0, sub {
my $len = sysread $self->{fh}, $self->{rbuf}, 256, length $self->{rbuf};
defined $len || $self->eof;
view release on metacpan or search on metacpan
my ($self) = @_;
delete $self->{fh};
delete $self->{command};
Scalar::Util::weaken $self;
$self->{retry_w} = AnyEvent->timer (after => 1, cb => sub {
delete $self->{retry_w};
$self->connect;
});
}
}
$self->interval_timer;
});
Scalar::Util::weaken $self;
}
sub connect {
my ($self) = @_;
} else {
$self->event ("error");
}
};
Scalar::Util::weaken $self;
}
sub drain_wbuf {
my ($self) = @_;
$self->{stretch} = $option{stretch} || 1;
$self->{compress} = $option{compress};
$self->{imterval} /= $self->{stretch};
Scalar::Util::weaken $self;
$self->{replay_cb} = sub {
my $line = <$fh>;
if (2 > length $line) {
view release on metacpan or search on metacpan
t/02-Slot.t view on Meta::CPAN
# Log::Log4perl->easy_init($DEBUG);
use Gear;
use AnyEvent;
use AnyEvent::Gearman;
use AnyEvent::Gearman::WorkerPool::Slot;
use Scalar::Util qw(weaken);
my $port = '9955';
my @js = ("localhost:$port");
my $cv = AE::cv;
my $t = AE::timer 10,0,sub{ $cv->send('timeout')};
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
" return \$_[0]->{%s} = do { my \$self = \$_[0]; %s }\n" .
" unless \$#_ > 0 or defined \$_[0]->{%s};\n",
weak_init =>
" return do {\n" .
" \$_[0]->{%s} = do { my \$self = \$_[0]; %s };\n" .
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n" .
" \$_[0]->{%s};\n" .
" } unless \$#_ > 0 or defined \$_[0]->{%s};\n",
return_if_get =>
" return \$_[0]->{%s} unless \$#_ > 0;\n",
set =>
" \$_[0]->{%s} = \$_[1];\n",
weaken =>
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n",
sub_end =>
" return \$_[0]->{%s};\n}\n",
);
sub field {
inc/Spiffy.pm view on Meta::CPAN
local *paired_arguments = sub { (qw(-package -init)) };
Spiffy->parse_arguments(@_);
};
my ($field, $default) = @values;
$package = $args->{-package} if defined $args->{-package};
die "Cannot have a default for a weakened field ($field)"
if defined $default && $args->{-weak};
return if defined &{"${package}::$field"};
require Scalar::Util if $args->{-weak};
my $default_string =
( ref($default) eq 'ARRAY' and not @$default )
inc/Spiffy.pm view on Meta::CPAN
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
$code .= sprintf $code{weaken}, $field, $field
if $args->{-weak};
$code .= sprintf $code{sub_end}, $field;
my $sub = eval $code;
die $@ if $@;
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
" return \$_[0]->{%s} = do { my \$self = \$_[0]; %s }\n" .
" unless \$#_ > 0 or defined \$_[0]->{%s};\n",
weak_init =>
" return do {\n" .
" \$_[0]->{%s} = do { my \$self = \$_[0]; %s };\n" .
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n" .
" \$_[0]->{%s};\n" .
" } unless \$#_ > 0 or defined \$_[0]->{%s};\n",
return_if_get =>
" return \$_[0]->{%s} unless \$#_ > 0;\n",
set =>
" \$_[0]->{%s} = \$_[1];\n",
weaken =>
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n",
sub_end =>
" return \$_[0]->{%s};\n}\n",
);
sub field {
inc/Spiffy.pm view on Meta::CPAN
local *paired_arguments = sub { (qw(-package -init)) };
Spiffy->parse_arguments(@_);
};
my ($field, $default) = @values;
$package = $args->{-package} if defined $args->{-package};
die "Cannot have a default for a weakened field ($field)"
if defined $default && $args->{-weak};
return if defined &{"${package}::$field"};
require Scalar::Util if $args->{-weak};
my $default_string =
( ref($default) eq 'ARRAY' and not @$default )
inc/Spiffy.pm view on Meta::CPAN
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
$code .= sprintf $code{weaken}, $field, $field
if $args->{-weak};
$code .= sprintf $code{sub_end}, $field;
my $sub = eval $code;
die $@ if $@;
view release on metacpan or search on metacpan
lib/AnyEvent/HTTPD/SendMultiHeaderPatch.pm view on Meta::CPAN
use AnyEvent::HTTPD;
use AnyEvent::HTTPD::Util;
use AnyEvent::HTTPD::HTTPConnection;
use Scalar::Util qw(weaken);
push @AnyEvent::HTTPD::Util::EXPORT, qw(header_add header_gets);
*AnyEvent::HTTPD::Util::header_add = sub {
my ($hdrs, $name, $value) = @_;
lib/AnyEvent/HTTPD/SendMultiHeaderPatch.pm view on Meta::CPAN
$self->response_done;
return;
}
if (ref ($content) eq 'CODE') {
weaken $self;
my $chunk_cb = sub {
my ($chunk) = @_;
return 0 unless defined ($self) && defined ($self->{hdl}) && !$self->{disconnected};
view release on metacpan or search on metacpan
lib/AnyEvent/HTTPD.pm view on Meta::CPAN
package AnyEvent::HTTPD;
use common::sense;
use Scalar::Util qw/weaken/;
use URI;
use AnyEvent::HTTPD::Request;
use AnyEvent::HTTPD::Util;
use base qw/AnyEvent::HTTPD::HTTPServer/;
lib/AnyEvent/HTTPD.pm view on Meta::CPAN
$self->reg_cb (
connect => sub {
my ($self, $con) = @_;
weaken $self;
$self->{conns}->{$con} = $con->reg_cb (
request => sub {
my ($con, $meth, $url, $hdr, $cont) = @_;
#d# warn "REQUEST: $meth, $url, [$cont] " . join (',', %$hdr) . "\n";
lib/AnyEvent/HTTPD.pm view on Meta::CPAN
$cont = parse_urlencoded ($url->query);
}
if ( scalar grep { $meth eq $_ } @{ $self->{allowed_methods} } ) {
weaken $con;
$self->handle_app_req (
$meth, $url, $hdr, $cont, $con->{host}, $con->{port},
sub {
$con->response (@_) if $con;
view release on metacpan or search on metacpan
lib/AnyEvent/Handle/Throttle.pm view on Meta::CPAN
}
sub start_read {
my ($self) = @_;
unless ($self->{_rw} || $self->{_eof} || !$self->{fh}) {
Scalar::Util::weaken $self;
$self->{_rw} = AE::io $self->{fh}, 0, sub {
my ($read) = sort grep {defined} $global_read_size,
$self->{read_size};
my ($period) = sort grep {defined} $global_period,
$self->{_period};
lib/AnyEvent/Handle/Throttle.pm view on Meta::CPAN
}
sub _drain_wbuf {
my ($self) = @_;
if (!$self->{_ww} && $self->{wbuf} && length $self->{wbuf}) {
Scalar::Util::weaken $self;
my $cb;
my $poll = sub {
$self->{_ww} = AE::io $self->{fh}, 1, $cb
if length $self->{wbuf};
};
view release on metacpan or search on metacpan
lib/AnyEvent/Handle/UDP.pm view on Meta::CPAN
my $time = $self->{$on_timeout};
my $error = do { local $! = Errno::ETIMEDOUT; "$!" };
$time ? $time->($self) : $self->_error(0, $error);
return if not exists $self->{$timeout};
}
Scalar::Util::weaken($self);
return if not $self;
$self->{$timer} = AE::timer($after, 0, sub {
delete $self->{$timer};
$callback->($self);
});
view release on metacpan or search on metacpan
lib/AnyEvent/Handle/ZeroMQ.pm view on Meta::CPAN
use strict;
use warnings;
use AE;
use ZeroMQ qw(:all);
use Scalar::Util qw(weaken);
use base qw(Exporter);
our %EXPORT_TAGS = ( constant => [qw(SOCKET RQUEUE WQUEUE RWATCHER WWATCHER ON_DRAIN DEALER ROUTER)] );
our @EXPORT_OK = map { @$_ } values %EXPORT_TAGS;
lib/AnyEvent/Handle/ZeroMQ.pm view on Meta::CPAN
[],
AE::io($fd, 0, sub { _consume_read_write($wself) }),
undef,
], $class;
weaken $wself;
if( exists $args{on_drain} ) {
on_drain($self, $args{on_drain});
}
if( exists $args{on_error} ) {
view release on metacpan or search on metacpan
lib/AnyEvent/IRC/Client.pm view on Meta::CPAN
package AnyEvent::IRC::Client;
use common::sense;
use Scalar::Util qw/weaken/;
use Encode;
use AnyEvent::Socket;
use AnyEvent::Handle;
use AnyEvent::IRC::Util
lib/AnyEvent/IRC/Client.pm view on Meta::CPAN
$type = lc $type;
my $id = ++$self->{dcc_id};
my $dcc = $self->{dcc}->{$id} = { id => $id, type => $type, dest => $dest };
weaken $dcc;
weaken $self;
$dcc->{timeout} = AnyEvent->timer (after => $timeout || 5 * 60, cb => sub {
$self->dcc_disconnect ($id, "TIMEOUT") if $self;
});
lib/AnyEvent/IRC/Client.pm view on Meta::CPAN
my ($self, $id, $timeout) = @_;
my $dcc = $self->{dcc}->{$id}
or return;
weaken $dcc;
weaken $self;
$dcc->{timeout} = AnyEvent->timer (after => $timeout || 5 * 60, cb => sub {
$self->dcc_disconnect ($id, "CONNECT TIMEOUT") if $self;
});
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
" return \$_[0]->{%s} = do { my \$self = \$_[0]; %s }\n" .
" unless \$#_ > 0 or defined \$_[0]->{%s};\n",
weak_init =>
" return do {\n" .
" \$_[0]->{%s} = do { my \$self = \$_[0]; %s };\n" .
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n" .
" \$_[0]->{%s};\n" .
" } unless \$#_ > 0 or defined \$_[0]->{%s};\n",
return_if_get =>
" return \$_[0]->{%s} unless \$#_ > 0;\n",
set =>
" \$_[0]->{%s} = \$_[1];\n",
weaken =>
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n",
sub_end =>
" return \$_[0]->{%s};\n}\n",
);
sub field {
inc/Spiffy.pm view on Meta::CPAN
local *paired_arguments = sub { (qw(-package -init)) };
Spiffy->parse_arguments(@_);
};
my ($field, $default) = @values;
$package = $args->{-package} if defined $args->{-package};
die "Cannot have a default for a weakened field ($field)"
if defined $default && $args->{-weak};
return if defined &{"${package}::$field"};
require Scalar::Util if $args->{-weak};
my $default_string =
( ref($default) eq 'ARRAY' and not @$default )
inc/Spiffy.pm view on Meta::CPAN
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
$code .= sprintf $code{weaken}, $field, $field
if $args->{-weak};
$code .= sprintf $code{sub_end}, $field;
my $sub = eval $code;
die $@ if $@;
view release on metacpan or search on metacpan
inc/Spiffy.pm view on Meta::CPAN
" return \$_[0]->{%s} = do { my \$self = \$_[0]; %s }\n" .
" unless \$#_ > 0 or defined \$_[0]->{%s};\n",
weak_init =>
" return do {\n" .
" \$_[0]->{%s} = do { my \$self = \$_[0]; %s };\n" .
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n" .
" \$_[0]->{%s};\n" .
" } unless \$#_ > 0 or defined \$_[0]->{%s};\n",
return_if_get =>
" return \$_[0]->{%s} unless \$#_ > 0;\n",
set =>
" \$_[0]->{%s} = \$_[1];\n",
weaken =>
" Scalar::Util::weaken(\$_[0]->{%s}) if ref \$_[0]->{%s};\n",
sub_end =>
" return \$_[0]->{%s};\n}\n",
);
sub field {
inc/Spiffy.pm view on Meta::CPAN
local *paired_arguments = sub { (qw(-package -init)) };
Spiffy->parse_arguments(@_);
};
my ($field, $default) = @values;
$package = $args->{-package} if defined $args->{-package};
die "Cannot have a default for a weakened field ($field)"
if defined $default && $args->{-weak};
return if defined &{"${package}::$field"};
require Scalar::Util if $args->{-weak};
my $default_string =
( ref($default) eq 'ARRAY' and not @$default )
inc/Spiffy.pm view on Meta::CPAN
}
$code .= sprintf $code{set_default}, $field, $default_string, $field
if defined $default;
$code .= sprintf $code{return_if_get}, $field;
$code .= sprintf $code{set}, $field;
$code .= sprintf $code{weaken}, $field, $field
if $args->{-weak};
$code .= sprintf $code{sub_end}, $field;
my $sub = eval $code;
die $@ if $@;
view release on metacpan or search on metacpan
lib/AnyEvent/Lingr.pm view on Meta::CPAN
$self->_on_error($res, $hdr);
}
});
}
Scalar::Util::weaken($self);
}
sub update_room_info {
my ($self) = @_;
$self->_get_channels;
lib/AnyEvent/Lingr.pm view on Meta::CPAN
}
else {
$self->_on_error($res, $hdr);
}
});
Scalar::Util::weaken($self);
}
sub _update_room_info {
my ($self, $rooms) = @_;
lib/AnyEvent/Lingr.pm view on Meta::CPAN
}
else {
$self->_on_error($res, $hdr);
}
});
Scalar::Util::weaken($self);
}
sub _start_observe {
my ($self, $rooms) = @_;
lib/AnyEvent/Lingr.pm view on Meta::CPAN
}
else {
$self->_on_error($res, $hdr);
}
});
Scalar::Util::weaken($self);
}
sub _polling {
my ($self) = @_;
lib/AnyEvent/Lingr.pm view on Meta::CPAN
}
else {
$self->_on_error($res, $hdr);
}
};
Scalar::Util::weaken($self);
$self->_polling_guard( $guard );
}
sub say {
lib/AnyEvent/Lingr.pm view on Meta::CPAN
else {
$self->_on_error($res, $hdr);
}
});
Scalar::Util::weaken($self);
}
1;
__END__
view release on metacpan or search on metacpan
MP/Kernel.pm view on Meta::CPAN
_unmonitor undef, $portid, delete $NODE{$SRCNODE}{rmon}{$portid}
if exists $NODE{$SRCNODE};
},
mon1 => sub { # start monitoring a port for another node
my $portid = shift;
Scalar::Util::weaken (my $node = $NODE{$SRCNODE});
_monitor undef, $portid, $node->{rmon}{$portid} = sub {
delete $node->{rmon}{$portid};
$node->send (["", kil0 => $portid, @_])
if $node && $node->{transport};
};