


IO::Select(3p)   Perl Programmers Reference Guide  IO::Select(3p)


NAME
       IO::Select - OO interface to the select system call

SYNOPSIS
           use IO::Select;

           $s = IO::Select->new();

           $s->add(\*STDIN);
           $s->add($some_handle);

           @ready = $s->can_read($timeout);

           @ready = IO::Select->new(@handles)->read(0);


DESCRIPTION
       The `IO::Select' package implements an object approach to
       the system `select' function call. It allows the user to
       see what IO handles, see the IO::Handle manpage, are ready
       for reading, writing or have an error condition pending.

CONSTRUCTOR
       new ( [ HANDLES ] )
           The constructor creates a new object and optionally
           initialises it with a set of handles.

METHODS
       add ( HANDLES )
           Add the list of handles to the `IO::Select' object. It
           is these values that will be returned when an event
           occurs. `IO::Select' keeps these values in a cache
           which is indexed by the `fileno' of the handle, so if
           more than one handle with the same `fileno' is speci-
           fied then only the last one is cached.

           Each handle can be an `IO::Handle' object, an integer
           or an array reference where the first element is a
           `IO::Handle' or an integer.

       remove ( HANDLES )
           Remove all the given handles from the object. This
           method also works by the `fileno' of the handles. So
           the exact handles that were added need not be passed,
           just handles that have an equivalent `fileno'

       exists ( HANDLE )
           Returns a true value (actually the handle itself) if
           it is present.  Returns undef otherwise.

       handles
           Return an array of all registered handles.





2000-04-06                 perl v5.6.0                          1





IO::Select(3p)   Perl Programmers Reference Guide  IO::Select(3p)


       can_read ( [ TIMEOUT ] )
           Return an array of handles that are ready for reading.
           `TIMEOUT' is the maximum amount of time to wait before
           returning an empty list. If `TIMEOUT' is not given and
           any handles are registered then the call will block.

       can_write ( [ TIMEOUT ] )
           Same as `can_read' except check for handles that can
           be written to.

       has_exception ( [ TIMEOUT ] )
           Same as `can_read' except check for handles that have
           an exception condition, for example pending out-of-
           band data.

       count ()
           Returns the number of handles that the object will
           check for when one of the `can_' methods is called or
           the object is passed to the `select' static method.

       bits()
           Return the bit string suitable as argument to the core
           select() call.

       select ( READ, WRITE, ERROR [, TIMEOUT ] )
           `select' is a static method, that is you call it with
           the package name like `new'. `READ', `WRITE' and
           `ERROR' are either `undef' or `IO::Select' objects.
           `TIMEOUT' is optional and has the same effect as for
           the core select call.

           The result will be an array of 3 elements, each a ref-
           erence to an array which will hold the handles that
           are ready for reading, writing and have error condi-
           tions respectively. Upon error an empty array is
           returned.

EXAMPLE
       Here is a short example which shows how `IO::Select' could
       be used to write a server which communicates with several
       sockets while also listening for more connections on a
       listen socket

           use IO::Select;
           use IO::Socket;

           $lsn = new IO::Socket::INET(Listen => 1, LocalPort => 8080);
           $sel = new IO::Select( $lsn );









2000-04-06                 perl v5.6.0                          2





IO::Select(3p)   Perl Programmers Reference Guide  IO::Select(3p)


           while(@ready = $sel->can_read) {
               foreach $fh (@ready) {
                   if($fh == $lsn) {
                       # Create a new socket
                       $new = $lsn->accept;
                       $sel->add($new);
                   }
                   else {
                       # Process socket

                       # Maybe we have finished with the socket
                       $sel->remove($fh);
                       $fh->close;
                   }
               }
           }


AUTHOR
       Graham Barr. Currently maintained by the Perl Porters.
       Please report all bugs to <perl5-porters@perl.org>.

COPYRIGHT
       Copyright (c) 1997-8 Graham Barr <gbarr@pobox.com>. All
       rights reserved.  This program is free software; you can
       redistribute it and/or modify it under the same terms as
       Perl itself.






























2000-04-06                 perl v5.6.0                          3


