view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

# This line is here to convince "autouse" into believing we are autousable.
sub can {
    ($_[1] eq 'import' and caller()->isa('autouse'))
        ? \&Exporter::import        # pacify autouse's equality test
        : $_[0]->SUPER::can($_[1])  # normal case
}

# TODO
#
# Exported functions like field and super should be hidden so as not to

 view release on metacpan or  search on metacpan

lib/AnyEvent/DBI/MySQL.pm  view on Meta::CPAN

sub DESTROY {
    my ($dbh) = @_;

    if ($GLOBAL_DESTRUCT) {
        return $dbh->SUPER::DESTROY();
    }

    $DATA[ $dbh->{$PRIVATE} ] = {};
    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}) {

lib/AnyEvent/DBI/MySQL.pm  view on Meta::CPAN

        $args[1] //= {};
        $args[1]->{async} //= 1;
        if (!$args[1]->{async}) {
            my $cb = delete $data->{cb};
            my $h  = delete $data->{h};
            $cb->( $dbh->SUPER::do(@args), $h );
            return;
        }
    }
    else {
        $args[1] //= {};
        if ($args[1]->{async}) {
            croak q{callback required};
        }
    }
    return $dbh->SUPER::do(@args);
}

sub prepare {
    my ($dbh, @args) = @_;
    local $SIG{__WARN__} = sub { (my $msg=shift)=~s/ at .*//ms; carp $msg };
    $args[1] //= {};
    $args[1]->{async} //= 1;
    my $sth = $dbh->SUPER::prepare(@args) or return;
    $sth->{$PRIVATE} = $dbh->{$PRIVATE};
    $sth->{$PRIVATE_async} = $args[1]->{async};
    return $sth;
}

lib/AnyEvent/DBI/MySQL.pm  view on Meta::CPAN

    selectrow_arrayref
    selectall_arrayref
);
for (@methods) {
    my $method = $_;
    my $super = "SUPER::$method";
    no strict 'refs';
    *{$method} = sub {
        my ($dbh, @args) = @_;
        local $SIG{__WARN__} = sub { (my $msg=shift)=~s/ at .*//ms; carp $msg };

lib/AnyEvent/DBI/MySQL.pm  view on Meta::CPAN

        $data->{cb} = pop @args;
        $data->{h} = $sth;
        if (!$sth->{$PRIVATE_async}) {
            my $cb = delete $data->{cb};
            my $h  = delete $data->{h};
            $cb->( $sth->SUPER::execute(@args), $h );
            return;
        }
        $sth->SUPER::execute(@args);
        if ($sth->err) { # execute failed, I/O won't happens
            my $cb = delete $data->{cb};
            my $h  = delete $data->{h};
            my $args=delete $data->{call_again};
            $cb->( undef, $h, $args // () );

lib/AnyEvent/DBI/MySQL.pm  view on Meta::CPAN

        return;
    }
    elsif ($sth->{$PRIVATE_async}) {
        croak q{callback required};
    }
    return $sth->SUPER::execute(@args);
}


package AnyEvent::DBI::MySQL::st::ready;
use base qw( DBI::st );

 view release on metacpan or  search on metacpan

lib/AnyEvent/DNS/Cache/Simple.pm  view on Meta::CPAN

        }
        return $cb->($res);
    }

    # request
    $self->SUPER::request($req, sub {
        my ($res) = @_;
        if ( !@_ ) {
            $self->{adcs_cache}->set($cache_key, [undef, $self->{adcs_negative_ttl} + Time::HiRes::time() ], $self->{adcs_negative_ttl});
            return $cb->();
        }

 view release on metacpan or  search on metacpan

lib/AnyEvent/DNS/EtcHosts.pm  view on Meta::CPAN

            warn "res = " . Dumper $res if DEBUG;

            return $cb->($res);
        }

        return $self->SUPER::request(
            $req,
            sub {
                my ($res) = @_;
                warn "SUPER::request res = " . Dumper $res if DEBUG;
                $cb->($res);
            }
        );

    }

 view release on metacpan or  search on metacpan

lib/AnyEvent/Filesys/Watcher/FSEvents.pm  view on Meta::CPAN

sub new {
	my ($class, %args) = @_;

	$args{interval} = 0.1 if !exists $args{interval};

	my $self = $class->SUPER::_new(%args);

	delete $args{directories};
	delete $args{callback};
	delete $args{filter};
	my $fs_monitor = Mac::FSEvents->new({

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

# This line is here to convince "autouse" into believing we are autousable.
sub can {
    ($_[1] eq 'import' and caller()->isa('autouse'))
        ? \&Exporter::import        # pacify autouse's equality test
        : $_[0]->SUPER::can($_[1])  # normal case
}

# TODO
#
# Exported functions like field and super should be hidden so as not to

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

# This line is here to convince "autouse" into believing we are autousable.
sub can {
    ($_[1] eq 'import' and caller()->isa('autouse'))
        ? \&Exporter::import        # pacify autouse's equality test
        : $_[0]->SUPER::can($_[1])  # normal case
}

# TODO
#
# Exported functions like field and super should be hidden so as not to

 view release on metacpan or  search on metacpan

lib/AnyEvent/Git/Wrapper.pm  view on Meta::CPAN

    my($dir, %opts) = @_;
    $dir = "$dir" if blessed $dir;
    $args = { dir => $dir, %opts };
  }
  my $cache_version = delete $args->{cache_version};
  my $self = $class->SUPER::new($args);
  $self->{ae_cache_version} = $cache_version;
  $self;
}

lib/AnyEvent/Git/Wrapper.pm  view on Meta::CPAN

  {
    $cv = pop;
  }
  else
  {
    return $self->SUPER::RUN(@_);
  }

  my $cmd = shift;

  my $customize;

lib/AnyEvent/Git/Wrapper.pm  view on Meta::CPAN

  {
    $cv = pop;
  }
  else
  {
    return $self->SUPER::status(@_);
  }

  my $opt = ref $_[0] eq 'HASH' ? shift : {};
  $opt->{porcelain} = 1;

lib/AnyEvent/Git/Wrapper.pm  view on Meta::CPAN

  {
    $cv = pop;
  }
  else
  {
    return $self->SUPER::log(@_);
  }
  
  my $cb;
  if(ref($_[-1]) eq 'CODE')
  {

lib/AnyEvent/Git/Wrapper.pm  view on Meta::CPAN

  }
  else
  {
    if($self->{ae_cache_version} && $self->{ae_version})
    { return $self->{ae_version} }
    $self->{ae_version} = $self->SUPER::version(@_);
    return $self->{ae_version};
  }
  
  if($self->{ae_cache_version} && $self->{ae_version})
  {

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

# This line is here to convince "autouse" into believing we are autousable.
sub can {
    ($_[1] eq 'import' and caller()->isa('autouse'))
        ? \&Exporter::import        # pacify autouse's equality test
        : $_[0]->SUPER::can($_[1])  # normal case
}

# TODO
#
# Exported functions like field and super should be hidden so as not to

 view release on metacpan or  search on metacpan

lib/AnyEvent/Groonga.pm  view on Meta::CPAN

__PACKAGE__->mk_accessors($_)
    for qw( protocol host port groonga_path database_path command_list debug);

sub new {
    my $class = shift;
    my $self  = $class->SUPER::new(
        {   protocol      => 'gqtp',
            host          => 'localhost',
            port          => '10041',
            groonga_path  => which("groonga") || undef,
            database_path => undef,

 view release on metacpan or  search on metacpan

lib/AnyEvent/HTTP/LWP/UserAgent/Determined.pm  view on Meta::CPAN

  $loop = sub {
    my $pause_if_unsuccessful = shift @timing_tries;

    $before_c and $before_c->(
      $self, \@timing_tries, $pause_if_unsuccessful, $determination, \@args);
    $self->SUPER::simple_request_async(@args)->cb(sub {
      my $resp = shift->recv;
      $after_c and $after_c->(
        $self, \@timing_tries, $pause_if_unsuccessful, $determination, \@args, $resp);

      my $code = $resp->code;

lib/AnyEvent/HTTP/LWP/UserAgent/Determined.pm  view on Meta::CPAN

#--------------------------------------------------------------------------
# extracted from LWP::UserAgent::Determined

sub new {
  my $self = shift->SUPER::new(@_);
  $self->_determined_init();
  return $self;
}

#==========================================================================

 view release on metacpan or  search on metacpan

lib/AnyEvent/HTTP/LWP/UserAgent.pm  view on Meta::CPAN

sub conn_cache {
    my $self = shift;

    my $res = $self->SUPER::conn_cache(@_);
    my $cache = $self->SUPER::conn_cache;
    if ($cache) {
        my $total_capacity = $cache->total_capacity;
        $total_capacity = 100_000 unless(defined($total_capacity));
        $AnyEvent::HTTP::ACTIVE = $total_capacity;
    }

 view release on metacpan or  search on metacpan

lib/AnyEvent/HTTP/Request.pm  view on Meta::CPAN

use parent 'AnyEvent::HTTP::Message';


sub new {
  my $class = shift;
  my $self = $class->SUPER::new(@_);

  $self->{method} = uc $self->{method};

  return $self;
}

 view release on metacpan or  search on metacpan

lib/AnyEvent/HTTPD/ExtDirect.pm  view on Meta::CPAN

    }
    
    # AnyEvent::HTTPD wants only IP addresses
    $arg{host} = '127.0.0.1' if $arg{host} =~ /localhost/io;

    my $self = $class->SUPER::new(%arg);
    
    $self->config($config);
    $self->api($api);

    return $self;

lib/AnyEvent/HTTPD/ExtDirect.pm  view on Meta::CPAN

        api_path    => $config->api_path,
        router_path => $config->router_path,
        poll_path   => $config->poll_path,
    );

    $self->SUPER::run();
}

### PUBLIC INSTANCE METHOD ###
#
# Handle Ext.Direct API calls

 view release on metacpan or  search on metacpan

lib/AnyEvent/HTTPD/Router.pm  view on Meta::CPAN

    my $dispatcher_class = delete $args{dispatcher_class}
        || 'AnyEvent::HTTPD::Router::DefaultDispatcher';
    my $known_methods    = delete $args{known_methods}
        || [ qw/GET HEAD POST PUT PATCH DELETE TRACE OPTIONS CONNECT/ ];

    my $self = $class->SUPER::new(%args);

    $self->{known_methods} = $known_methods;
    $self->{dispatcher}    = defined $dispatcher
        ? $dispatcher
        : $dispatcher_class->new();

 view release on metacpan or  search on metacpan

lib/AnyEvent/HTTPD.pm  view on Meta::CPAN

=cut

sub new {
   my $this  = shift;
   my $class = ref($this) || $this;
   my $self  = $class->SUPER::new (
      request_class => "AnyEvent::HTTPD::Request",
      @_
   );

   $self->reg_cb (

 view release on metacpan or  search on metacpan

lib/AnyEvent/Handle/Throttle.pm  view on Meta::CPAN

            $self->{_upload_speed}  = $self->{_download_speed} = 0;
        };
        $self->{_period} ||= 1;
        $self->{_reset} = AE::timer(0, $self->{_period}, $reset);
        $reset->();
        $self->SUPER::_start(@_);
    }

    sub start_read {
        my ($self) = @_;
        unless ($self->{_rw} || $self->{_eof} || !$self->{fh}) {

 view release on metacpan or  search on metacpan

lib/AnyEvent/Handle/ZeroMQ/Dealer.pm  view on Meta::CPAN

=cut

sub new {
    my $class = shift;
    my $self = $class->SUPER::new(@_);

    $self->[DEALER] = [];
    $self->[DEALER][SLOT] = [];
    return $self;
}

lib/AnyEvent/Handle/ZeroMQ/Dealer.pm  view on Meta::CPAN

    my $n = unpack 'V', shift(@$msgs)->data;

    my $cb = delete $self->[DEALER][SLOT][$n];
    if( !$cb ) {
	$self->SUPER::push_read(\&_dealer_read_cb);
	return;
    }

    0 while( @$msgs && shift(@$msgs)->size );
    $cb->($self, $msgs);

lib/AnyEvent/Handle/ZeroMQ/Dealer.pm  view on Meta::CPAN

    ++$n while $self->[DEALER][SLOT][$n];
    $self->[DEALER][SLOT][$n] = $cb;

    unshift @$msgs, pack('V', $n), '';

    $self->SUPER::push_write($msgs);
    $self->SUPER::push_read(\&_dealer_read_cb);
}

=head2 push_read

Don't use this.

 view release on metacpan or  search on metacpan

lib/AnyEvent/IRC/Server.pm  view on Meta::CPAN

    print Term::ANSIColor::colored(["cyan"], $s);
}

sub new {
    my $class = shift;
    my $self = $class->SUPER::new(
        handles      => {}, # refaddr($handle) => $handle
        channels     => {},
        topics       => {},
        spoofed_nick => {},
        nick2handle  => {}, # $nick => $hanldle,

 view release on metacpan or  search on metacpan

lib/AnyEvent/IRC/Client.pm  view on Meta::CPAN

);

sub new {
   my $this = shift;
   my $class = ref($this) || $this;
   my $self = $class->SUPER::new (@_);

   $self->reg_cb (irc_001     => \&welcome_cb);
   $self->reg_cb (irc_376     => \&welcome_cb);
   $self->reg_cb (irc_422     => \&welcome_cb);
   $self->reg_cb (irc_005     => \&isupport_cb);

lib/AnyEvent/IRC/Client.pm  view on Meta::CPAN

            delete $self->{register_cb_guard};
         }
      );
   }

   $self->SUPER::connect ($host, $port, $timeout);
}

=item $cl->register ($nick, $user, $real, $server_pass)

Sends the IRC registration commands NICK and USER.

lib/AnyEvent/IRC/Client.pm  view on Meta::CPAN

=cut

sub send_msg {
   my ($self, @a) = @_;
   $self->event (debug_send => @a);
   $self->SUPER::send_msg (@a);
}

=item $cl->send_srv ($command, @params)

This function sends an IRC message that is constructed by C<mk_msg (undef,

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

# This line is here to convince "autouse" into believing we are autousable.
sub can {
    ($_[1] eq 'import' and caller()->isa('autouse'))
        ? \&Exporter::import        # pacify autouse's equality test
        : $_[0]->SUPER::can($_[1])  # normal case
}

# TODO
#
# Exported functions like field and super should be hidden so as not to

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

# This line is here to convince "autouse" into believing we are autousable.
sub can {
    ($_[1] eq 'import' and caller()->isa('autouse'))
        ? \&Exporter::import        # pacify autouse's equality test
        : $_[0]->SUPER::can($_[1])  # normal case
}

# TODO
#
# Exported functions like field and super should be hidden so as not to

 view release on metacpan or  search on metacpan

lib/AnyEvent/Kanye.pm  view on Meta::CPAN

sub send {
	my ( $self, $thing ) = @_;
	my $name = ref($thing) || 'value';

	$self->SUPER::send(
		"This $name is pretty good, and I'mma let "    .
		"you finish, but Beyoncé had one of the best " .
		PL($name) . " of all time!"
	);
}

 view release on metacpan or  search on metacpan

lib/AnyEvent/Memcached/Peer.pm  view on Meta::CPAN

sub DEBUG () { 0 }

use AnyEvent::Memcached::Conn;

sub new {
	my $self = shift->SUPER::new(
		rawcon    => 'AnyEvent::Memcached::Conn',
		reconnect => 1,
		@_,
	);
	$self->{waitingcb} = {};

lib/AnyEvent/Memcached/Peer.pm  view on Meta::CPAN

				$self->{waitingcb}{$_}(undef,$e);
			}
			delete $self->{waitingcb}{$_};
		}
	} );
	$self->SUPER::connect(@_);
	return;
}

sub conntrack {
	my $self = shift;

 view release on metacpan or  search on metacpan

lib/Module/AnyEvent/Helper/PPI/Transform/Net/Amazon/S3.pm  view on Meta::CPAN

use parent qw(PPI::Transform::PackageName);

sub new
{
    my ($self) = @_;
    my $ret = $self->SUPER::new(
        -all => sub {
            s/^Net::Amazon::S3\b/AnyEvent::Net::Amazon::S3/g;
            s/^LWP::UserAgent\b/AnyEvent::HTTP::LWP::UserAgent/g;
            s/^Data::Stream::Bulk::Callback\b/Data::Stream::Bulk::AnyEvent/g;
        }

 view release on metacpan or  search on metacpan

lib/AnyEvent/Onkyo.pm  view on Meta::CPAN

sub new {
  my ($pkg, %p) = @_;
  croak $pkg.'->new: callback parameter is required' unless ($p{callback});
  my $self = $pkg->SUPER::new(device => 'discover', %p);
  $self;
}


sub command {
  my $self = shift;
  my $cv = AnyEvent->condvar;
  my $weak_cv = $cv;
  weaken $weak_cv;
  $self->SUPER::command(@_, subname 'command_cb' => sub {
                          $weak_cv->send() if ($weak_cv);
                        });
  return $cv;
}

sub _open {
  my $self = shift;
  $self->SUPER::_open($self->_open_condvar);
  return 1;
}

sub _open_tcp_port {
  my ($self, $cv) = @_;

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

# This line is here to convince "autouse" into believing we are autousable.
sub can {
    ($_[1] eq 'import' and caller()->isa('autouse'))
        ? \&Exporter::import        # pacify autouse's equality test
        : $_[0]->SUPER::can($_[1])  # normal case
}

# TODO
#
# Exported functions like field and super should be hidden so as not to

 view release on metacpan or  search on metacpan

lib/AnyEvent/Plurk.pm  view on Meta::CPAN

}

sub new {
   my $this  = shift;
   my $class = ref($this) || $this;
   my $self  = $class->SUPER::new(@_);

   unless (defined $self->{api_key}) {
      croak "no 'api_key' given to AnyEvent::Plurk\n";
   }

 view release on metacpan or  search on metacpan

lib/AnyEvent/Processor/Conversion.pm  view on Meta::CPAN

sub run  {
    my $self = shift;
    $self->writer->begin();
    $self->SUPER::run();
    $self->writer->end();
};


sub process {
    my $self = shift;
    my $record = $self->reader->read();
    if ( $record ) {
        $self->SUPER::process();
        my $converter = $self->converter;
        my $converted_record = 
            $converter ? $converter->convert( $record ) : $record;
        unless ( $converted_record ) {
            # Conversion échouée mais il reste des enregistrements

 view release on metacpan or  search on metacpan

lib/AnyEvent/RFXCOM/RX.pm  view on Meta::CPAN

sub new {
  my ($pkg, %p) = @_;
  croak $pkg.'->new: callback parameter is required' unless ($p{callback});
  my $self = $pkg->SUPER::new(%p);
  $self;
}

sub _handle_setup {
  my $self = shift;

lib/AnyEvent/RFXCOM/RX.pm  view on Meta::CPAN

  1;
}

sub _open {
  my $self = shift;
  $self->SUPER::_open($self->_open_condvar);
  return 1;
}

sub _open_serial_port {
  my ($self, $cv) = @_;
  my $fh = $self->SUPER::_open_serial_port;
  $cv->send($fh);
  return $cv;
}

sub DESTROY {

lib/AnyEvent/RFXCOM/RX.pm  view on Meta::CPAN

}


sub cleanup {
  my ($self, $error) = @_;
  $self->SUPER::cleanup(@_);
  undef $self->{discard_timer};
  undef $self->{dup_timer};
}