/ 
IO-Async-0.10
River stage three • 121 direct dependents • 154 total dependents
/ IO::Async::Buffer

NAME

IO::Async::Buffer - a class which implements asynchronous reading and writing data buffers around a connected handle

SYNOPSIS

use IO::Socket::INET;
use IO::Async::Buffer;

my $socket = IO::Socket::INET->new(
   PeerHost => "some.other.host",
   PeerPort => 12345,
   Blocking => 0,                   # This line is very important
);

my $buffer = IO::Async::Buffer->new(
   handle => $socket,

   on_read => sub {
      my ( $self, $buffref, $closed ) = @_;

      if( $$buffref =~ s/^(.*\n)// ) {
         print "Received a line $1";

         return 1;
      }

      if( $closed ) {
         print "Closed; last partial line is $$buffref\n";
      }

      return 0;
   }
);

$buffer->write( "An initial line here\n" );

my $set = IO::Async::Set::...
$set->add( $buffer );

Or

my $record_buffer = IO::Async::Buffer->new(
   handle => ...,

   on_read => sub {
      my ( $self, $buffref, $closed ) = @_;

      if( length $$buffref >= 16 ) {
         my $record = substr( $$buffref, 0, 16, "" );
         print "Received a 16-byte record: $record\n";

         return 1;
      }

      if( $closed and length $$buffref ) {
         print "Closed: a partial record still exists\n";
      }

      return 0;
   }
);

Or

use IO::Handle;

my $buffer = IO::Async::Buffer->new(
   read_handle  => \*STDIN,
   write_handle => \*STDOUT,
   ...
);

DESCRIPTION

This module provides a class for implementing asynchronous communications buffers behind connected handles. It provides buffering for both incoming and outgoing data, which are transferred to or from the actual handle as appropriate.

Data can be added to the outgoing buffer at any time using the write() method, and will be flushed whenever the underlying handle is notified as being write-ready. Whenever the handle is notified as being read-ready, the data is read in from the handle, and the on_read code is called to indicate the data is available.

This object may be used in one of two ways; with a callback function, or as a base class.

Callbacks

If certain keys are supplied to the constructor, they should contain CODE references to callback functions that will be called in the following manner:

$again = $on_read->( $self, \$buffer, $handleclosed )

$on_read_error->( $self, $errno )

$on_outgoing_empty->( $self )

$on_write_error->( $self, $errno )

A reference to the calling IO::Async::Buffer object is passed as the first argument, so that the callback can access it.

Base Class

If a subclass is built, then it can override the on_read or on_outgoing_empty methods, which will be called in the following manner:

$again = $self->on_read( \$buffer, $handleclosed )

$self->on_read_error( $errno )

$self->on_outgoing_empty()

$self->on_write_error( $errno )

The first argument to the on_read() callback is a reference to a plain perl string. The code should inspect and remove any data it likes, but is not required to remove all, or indeed any of the data. Any data remaining in the buffer will be preserved for the next call, the next time more data is received from the handle.

In this way, it is easy to implement code that reads records of some form when completed, but ignores partially-received records, until all the data is present. If the method is confident no more useful data remains, it should return a false value. If not, it should return a true value, and the method will be called again. This makes it easy to implement code that handles multiple incoming records at the same time. See the examples at the end of this documentation for more detail.

The second argument to the on_read() method is a scalar indicating whether the handle has been closed. Normally it is false, but will become true once the handle closes. A reference to the buffer is passed to the method in the usual way, so it may inspect data contained in it. Once the method returns a false value, it will not be called again, as the handle is now closed and no more data can arrive.

The on_read_error and on_write_error callbacks are passed the value of $! at the time the error occured. (The $! variable itself, by its nature, may have changed from the original error by the time this callback runs so it should always use the value passed in).

If an error occurs when the corresponding error callback is not supplied, and there is not a subclass method for it, then the close() method is called instead.

The on_outgoing_empty callback is not passed any arguments.

CONSTRUCTOR

$buffer = IO::Async::Buffer->new( %params )

This function returns a new instance of a IO::Async::Buffer object. The %params hash takes the following keys:

handle => $handle

The handle object to wrap. Must implement fileno, sysread and syswrite methods in the way that IO::Handle does.

on_read => CODE

A CODE reference for when more data is available in the internal receiving buffer.

on_incoming_data => CODE

This option is deprecated and should not be used in new code. It is maintained as a backward-compatibility synonym for on_read.

on_read_error => CODE

A CODE reference for when the sysread() method on the read handle fails.

on_outgoing_empty => CODE

A CODE reference for when the writing data buffer becomes empty.

on_write_error => CODE

A CODE reference for when the syswrite() method on the write handle fails.

It is required that either an on_read callback reference is passed, or that the object provides an on_read method. It is optional whether either is true for on_outgoing_empty; if neither is supplied then no action will be taken when the writing buffer becomes empty.

METHODS

$buffer->write( $data )

This method adds data to the outgoing data queue. The data is not yet sent to the handle; this will be done later in the on_write_ready() method.

$data

A scalar containing data to write

DEPRECATED METHODS

These methods are mainained for backward compatibility with existing code. They should not be used in new code, and existing code should be modified to use the replacements.

$buffer->send( $data )

A synonym for write().

EXAMPLES

A line-based on_read() method

The following on_read() method accepts incoming '\n'-terminated lines and prints them to the program's STDOUT stream.

sub on_read
{
   my $self = shift;
   my ( $buffref, $handleclosed ) = @_;

   if( $$buffref =~ s/^(.*\n)// ) {
      print "Received a line: $1";
      return 1;
   }

   return 0;
}

Because a reference to the buffer itself is passed, it is simple to use a s/// regular expression on the scalar it points at, to both check if data is ready (i.e. a whole line), and to remove it from the buffer. If no data is available then 0 is returned, to indicate it should not be tried again. If a line was successfully extracted, then 1 is returned, to indicate it should try again in case more lines exist in the buffer.

SEE ALSO

  • IO::Handle - Supply object methods for I/O handles

AUTHOR

Paul Evans <leonerd@leonerd.org.uk>