[ViewVC] Diff of: cvs/AnyEvent/lib/AnyEvent/Handle.pm

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.219 by root, Mon Jul 18 01:19:43 2011 UTC vs.
Revision 1.227 by root, Tue Jan 10 13:32:23 2012 UTC

    my $hdl; $hdl = new AnyEvent::Handle
       fh => \*STDIN,
       on_error => sub {
          my ($hdl, $fatal, $msg) = @_;
-         warn "got error $msg\n";
+         AE::log error => "got error $msg\n";
          $hdl->destroy;
          $cv->send;
       };
    # send some request line
    $hdl->push_write ("getinfo\015\012");
    # read the response line
    $hdl->push_read (line => sub {
       my ($hdl, $line) = @_;
-      warn "got line <$line>\n";
+      say "got line <$line>";
       $cv->send;
    });
    $cv->recv;
 already have occured on BSD systems), but at least it will protect you
 from most attacks.
 =item read_size => <bytes>
-The initial read block size, the number of bytes this module will try to
+The initial read block size, the number of bytes this module will try
-read during each loop iteration. Each handle object will consume at least
+to read during each loop iteration. Each handle object will consume
-this amount of memory for the read buffer as well, so when handling many
+at least this amount of memory for the read buffer as well, so when
-connections requirements). See also C<max_read_size>. Default: C<2048>.
+handling many connections watch out for memory requirements). See also
+C<max_read_size>. Default: C<2048>.
 =item max_read_size => <bytes>
 The maximum read buffer size used by the dynamic adjustment
 algorithm: Each time AnyEvent::Handle can read C<read_size> bytes in
 =cut
 register_write_type storable => sub {
    my ($self, $ref) = @_;
-   require Storable;
+   require Storable unless $Storable::VERSION;
    pack "w/a*", Storable::nfreeze ($ref)
 };
 =back
 Whenever the given C<type> is used, C<push_write> will the function with
 the handle object and the remaining arguments.
 The function is supposed to return a single octet string that will be
-appended to the write buffer, so you cna mentally treat this function as a
+appended to the write buffer, so you can mentally treat this function as a
 "arguments to on-the-wire-format" converter.
 Example: implement a custom write type C<join> that joins the remaining
 arguments using the first one.
 data.
 Example: read 2 bytes.
    $handle->push_read (chunk => 2, sub {
-      warn "yay ", unpack "H*", $_[1];
+      say "yay " . unpack "H*", $_[1];
    });
 =cut
 register_read_type chunk => sub {
    if (@_ < 3) {
       # this is more than twice as fast as the generic code below
       sub {
          $_[0]{rbuf} =~ s/^([^\015\012]*)(\015?\012)// or return;
-         $cb->($_[0], $1, $2);
+         $cb->($_[0], "$1", "$2");
          1
       }
    } else {
       $eol = quotemeta $eol unless ref $eol;
       $eol = qr|^(.*?)($eol)|s;
       sub {
          $_[0]{rbuf} =~ s/$eol// or return;
-         $cb->($_[0], $1, $2);
+         $cb->($_[0], "$1", "$2");
          1
       }
    }
 };
    sub {
       # accept
       if ($$rbuf =~ $accept) {
          $data .= substr $$rbuf, 0, $+[0], "";
-         $cb->($self, $data);
+         $cb->($_[0], $data);
          return 1;
       }
       # reject
       if ($reject && $$rbuf =~ $reject) {
-         $self->_error (Errno::EBADMSG);
+         $_[0]->_error (Errno::EBADMSG);
       }
       # skip
       if ($skip && $$rbuf =~ $skip) {
          $data .= substr $$rbuf, 0, $+[0], "";
    my ($self, $cb) = @_;
    sub {
       unless ($_[0]{rbuf} =~ s/^(0|[1-9][0-9]*)://) {
          if ($_[0]{rbuf} =~ /[^0-9]/) {
-            $self->_error (Errno::EBADMSG);
+            $_[0]->_error (Errno::EBADMSG);
          }
          return;
       }
       my $len = $1;
-      $self->unshift_read (chunk => $len, sub {
+      $_[0]->unshift_read (chunk => $len, sub {
          my $string = $_[1];
          $_[0]->unshift_read (chunk => 1, sub {
             if ($_[1] eq ",") {
                $cb->($_[0], $string);
             } else {
-               $self->_error (Errno::EBADMSG);
+               $_[0]->_error (Errno::EBADMSG);
             }
          });
       });
       1
    my $data;
    my $rbuf = \$self->{rbuf};
    sub {
-      my $ref = eval { $json->incr_parse ($self->{rbuf}) };
+      my $ref = eval { $json->incr_parse ($_[0]{rbuf}) };
       if ($ref) {
-         $self->{rbuf} = $json->incr_text;
+         $_[0]{rbuf} = $json->incr_text;
          $json->incr_text = "";
-         $cb->($self, $ref);
+         $cb->($_[0], $ref);
          1
       } elsif ($@) {
          # error case
          $json->incr_skip;
-         $self->{rbuf} = $json->incr_text;
+         $_[0]{rbuf} = $json->incr_text;
          $json->incr_text = "";
-         $self->_error (Errno::EBADMSG);
+         $_[0]->_error (Errno::EBADMSG);
          ()
       } else {
-         $self->{rbuf} = "";
+         $_[0]{rbuf} = "";
          ()
       }
    }
 };
 =cut
 register_read_type storable => sub {
    my ($self, $cb) = @_;
-   require Storable;
+   require Storable unless $Storable::VERSION;
    sub {
       # when we can use 5.10 we can use ".", but for 5.8 we use the re-pack method
       defined (my $len = eval { unpack "w", $_[0]{rbuf} })
          or return;
          # read remaining chunk
          $_[0]->unshift_read (chunk => $len, sub {
             if (my $ref = eval { Storable::thaw ($_[1]) }) {
                $cb->($_[0], $ref);
             } else {
-               $self->_error (Errno::EBADMSG);
+               $_[0]->_error (Errno::EBADMSG);
             }
          });
       }
       1
 some readings of the the SSL/TLS specifications basically require this
 attack to be working, as SSL/TLS implementations might stall sending data
 during a rehandshake.
 As a guideline, during the initial handshake, you should not stop reading,
-and as a client, it might cause problems, depending on your applciation.
+and as a client, it might cause problems, depending on your application.
 =cut
 sub stop_read {
    my ($self) = @_;
 Probably because your C<on_error> callback is being called instead: When
 you have outstanding requests in your read queue, then an EOF is
 considered an error as you clearly expected some data.
 To avoid this, make sure you have an empty read queue whenever your handle
-is supposed to be "idle" (i.e. connection closes are O.K.). You cna set
+is supposed to be "idle" (i.e. connection closes are O.K.). You can set
 an C<on_read> handler that simply pushes the first read requests in the
 queue.
 See also the next question, which explains this in a bit more detail.
 some data and raises the C<EPIPE> error when the connction is dropped
 unexpectedly.
 The second variant is a protocol where the client can drop the connection
 at any time. For TCP, this means that the server machine may run out of
-sockets easier, and in general, it means you cnanot distinguish a protocl
+sockets easier, and in general, it means you cannot distinguish a protocl
 failure/client crash from a normal connection close. Nevertheless, these
 kinds of protocols are common (and sometimes even the best solution to the
 problem).
 Having an outstanding read request at all times is possible if you ignore
 C<low_water_mark> this will be called precisely when all data has been
 written to the socket:
    $handle->push_write (...);
    $handle->on_drain (sub {
-      warn "all data submitted to the kernel\n";
+      AE::log debug => "all data submitted to the kernel\n";
       undef $handle;
    });
 If you just want to queue some data and then signal EOF to the other side,
 consider using C<< ->push_shutdown >> instead.

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents): Revision 1.219 by root, Mon Jul 18 01:19:43 2011 UTC vs. Revision 1.227 by root, Tue Jan 10 13:32:23 2012 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Handle.pm (file contents):
Revision 1.219 by root, Mon Jul 18 01:19:43 2011 UTC vs.
Revision 1.227 by root, Tue Jan 10 13:32:23 2012 UTC