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/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};
}

 view release on metacpan or  search on metacpan

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

use RTPG          0.3;

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

sub _tick {

 view release on metacpan or  search on metacpan

Gnu.pm  view on Meta::CPAN

   $out    = $arg{out} || *STDOUT;
   $prompt = $arg{prompt} // "> ";
   $cb     = $arg{on_line} || $arg{cb}
      or do { require Carp; Carp::croak ("AnyEvent::ReadLine::Gnu->new on_line callback argument mandatry, but missing") };

   $self = $class->SUPER::new ($arg{name} || $0, $in, $out);

   $Term::ReadLine::Gnu::Attribs{term_set} = ["", "", "", ""];
   $self->CallbackHandlerInstall ($prompt, \&on_line);

   $hidden = 1;

 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/Run.pm  view on Meta::CPAN

    my ($parent, $child) = AnyEvent::Util::portable_socketpair
        or croak "unable to create AnyEvent::Run socketpair: $!";
        
    $args{fh} = $child;
    
    my $self = $class->SUPER::new(%args);

    my $pid = fork;
    
    if ( $pid == 0 ) {
        # child

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

    my $self = shift;
    
    # XXX: doesn't play nice with linger option, so clear wbuf
    $self->{wbuf} = '';
    
    $self->SUPER::DESTROY(@_);
    
    if ( $self->{child_pid} ) {
        kill 9 => $self->{child_pid};
        waitpid $self->{child_pid}, 0;
    }

 view release on metacpan or  search on metacpan

t/testlib.pl  view on Meta::CPAN

sub new {
	my ($class,%args) = @_;
	my @lfields = qw( can_deliver_to dump_incoming dump_outgoing );
	my %largs = map { $_ => delete $args{$_} } @lfields;
	my $self = $class->SUPER::new( %args );
	if ( my $ct = delete $largs{can_deliver_to} ) {
		$self->{can_deliver_to} = _parse_addr($ct);
	}
	%$self = ( %$self, %largs );
	return $self;

t/testlib.pl  view on Meta::CPAN

		foreach (qw( addr proto port )) {
			next if ! $spec->{$_} || ! $ct->{$_};
			return if $spec->{$_} ne $ct->{$_};
		}
	}
	return $self->SUPER::can_deliver_to( @_ );
}

sub _parse_addr {
	my $addr = shift;
	$addr =~m{^(?:(udp|tcp):)?([\w\.-]+)(?::(\d+))?$} || die $addr;
	return { proto => $1, addr => $2, port => $3 }
}

sub receive {
	my $self = shift;
	my @rv = $self->SUPER::receive(@_) or return;
	invoke_callback( $self->{dump_incoming},@rv );
	return @rv;
}

sub deliver {
	my ($self,$packet,$to,$callback) = @_;
	invoke_callback( $self->{dump_outgoing},$packet,$to );
	return $self->SUPER::deliver( $packet,$to,$callback );
}



1;

 view release on metacpan or  search on metacpan

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

my %DECODE_MAP = reverse %ENCODE_MAP;


sub new {
    my $class = shift;
    my $self = $class->SUPER::new;

    $self->{connection_timeout_margin} = 250;
    $self->{connected} = 0;
    $self->{counter} = 0;

 view release on metacpan or  search on metacpan

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

    croak 'No host provided' unless $host;
    croak "ack value must be 0, undef, 'auto' or 'manual'"
        if $ack && $ack ne 'auto' && $ack ne 'manual';

    my $self = $class->SUPER::new;

    $self->{ack} = $ack;

    $port ||= ($ssl ? 61612 : 61613);

 view release on metacpan or  search on metacpan

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

  }
  $s->write_settings();
  sysopen($fh, $dev, O_RDWR|O_NOCTTY|O_NDELAY) or
    croak "sysopen of '$dev' failed: $!";
  $fh->autoflush(1);
  my $self = $pkg->SUPER::new(fh => $fh, %p);
  $self->{serial_port} = $s;
  $self;
}

 view release on metacpan or  search on metacpan

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

    # if the on_read is not provided, we never get notified of handle
    # close (presumably because no watchers are ever created)
    push @args, on_read => sub { } if $is_read;

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

    return $self;
}

sub on_finalize {

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

sub destroy {
    my ($self, @args) = @_;
    my $rbuf = $self->{rbuf};
    $self->_do_finalize;
    $self->SUPER::destroy(@args);
    $self->{rbuf} = $rbuf;
    $self->{destroyed} = 1;
    return;
}

 view release on metacpan or  search on metacpan

lib/AnyEvent/WebService/Notifo.pm  view on Meta::CPAN

  unless (ref($cb) eq 'CODE') {
    my $cv = $cb;
    $cb = sub { $cv->send(@_) };
  }

  my $req = $self->SUPER::send_notification(%args);
  return $self->_do_request($cb, $req);
}

sub _do_request {
  my ($self, $cb, $req) = @_;

 view release on metacpan or  search on metacpan

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

	my $methods = delete $args{'methods'};
	my $uri = delete $args{'uri'};
	$uri ||= "/RPC2";
	
	# get a new clean AnyEvent::HTTPD
	my $self = $class->SUPER::new(%args);
	return undef unless $self;
	
	# Now I'm AnyEvent::XMLRPC
	bless $self, $class;
	

 view release on metacpan or  search on metacpan

lib/AnyEvent/XMPP/Component.pm  view on Meta::CPAN

   unless (defined $args{port}) {
      $args{port} = 5347;
   }

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

   $self->{parser}->set_stream_cb (sub {
      my $secret = $self->{parser}->{parser}->xml_escape ($self->{secret});
      my $id = $self->{stream_id} = $_[0]->attr ('id');
      $self->{writer}->send_handshake ($id, $secret);

 view release on metacpan or  search on metacpan

inc/Module/Install/ExtraTests.pm  view on Meta::CPAN

  package # The newline tells PAUSE, "DO NOT INDEXING!"
  MY;
  sub test_via_harness {
    my $self = shift;

    return $self->SUPER::test_via_harness(@_)
      unless $use_extratests;

    my ($perl, $tests) = @_;
    my $a_str = -d 'xt/author'  ? 'xt/author'  : '';
    my $r_str = -d 'xt/release' ? 'xt/release' : '';

inc/Module/Install/ExtraTests.pm  view on Meta::CPAN

  }

  sub dist_test {
    my ($self, @args) = @_;

    return $self->SUPER::dist_test(@args)
      unless $use_extratests;

    my $text = $self->SUPER::dist_test(@args);
    my @lines = split /\n/, $text;
    $_ =~ s/ (\S*MAKE\S* test )/ RELEASE_TESTING=1 $1 / for grep { m/ test / } @lines;
    return join "\n", @lines;
  }
}

 view release on metacpan or  search on metacpan

lib/AnyMongo/BSON/OID.pm  view on Meta::CPAN

    builder => 'build_value',
);

sub BUILDARGS {
    my $class = shift;
    return $class->SUPER::BUILDARGS(flibble => @_) if @_ % 2;
    return $class->SUPER::BUILDARGS(@_);
}

sub build_value {
    my ($self, $str) = @_;
    $str = '' unless defined $str;

 view release on metacpan or  search on metacpan

inc/Pod/Markdown.pm  view on Meta::CPAN

# ABSTRACT: Convert POD to Markdown
use parent qw(Pod::Parser);

sub initialize {
    my $self = shift;
    $self->SUPER::initialize(@_);
    $self->_private;
    $self;
}

sub _private {