<h2>Edit File - Select.pm</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/perl5/IO/Select.pm">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;"># IO::Select.pm
#
# Copyright (c) 1997-8 Graham Barr &lt;gbarr@pobox.com&gt;. All rights reserved.
# This program is free software; you can redistribute it and/or
# modify it under the same terms as Perl itself.

package IO::Select;

use     strict;
use warnings::register;
use     vars qw($VERSION @ISA);
require Exporter;

$VERSION = &quot;1.22&quot;;

@ISA = qw(Exporter); # This is only so we can do version checking

sub VEC_BITS () {0}
sub FD_COUNT () {1}
sub FIRST_FD () {2}

sub new
{
 my $self = shift;
 my $type = ref($self) || $self;

 my $vec = bless [undef,0], $type;

 $vec-&gt;add(@_)
    if @_;

 $vec;
}

sub add
{
 shift-&gt;_update(&#039;add&#039;, @_);
}


sub remove
{
 shift-&gt;_update(&#039;remove&#039;, @_);
}


sub exists
{
 my $vec = shift;
 my $fno = $vec-&gt;_fileno(shift);
 return undef unless defined $fno;
 $vec-&gt;[$fno + FIRST_FD];
}


sub _fileno
{
 my($self, $f) = @_;
 return unless defined $f;
 $f = $f-&gt;[0] if ref($f) eq &#039;ARRAY&#039;;
 ($f =~ /^\d+$/) ? $f : fileno($f);
}

sub _update
{
 my $vec = shift;
 my $add = shift eq &#039;add&#039;;

 my $bits = $vec-&gt;[VEC_BITS];
 $bits = &#039;&#039; unless defined $bits;

 my $count = 0;
 my $f;
 foreach $f (@_)
  {
   my $fn = $vec-&gt;_fileno($f);
   if ($add) {
     next unless defined $fn;
     my $i = $fn + FIRST_FD;
     if (defined $vec-&gt;[$i]) {
	 $vec-&gt;[$i] = $f;  # if array rest might be different, so we update
	 next;
     }
     $vec-&gt;[FD_COUNT]++;
     vec($bits, $fn, 1) = 1;
     $vec-&gt;[$i] = $f;
   } else {      # remove
     if ( ! defined $fn ) { # remove if fileno undef&#039;d
       $fn = 0;
       for my $fe (@{$vec}[FIRST_FD .. $#$vec]) {
         if (defined($fe) &amp;&amp; $fe == $f) {
	   $vec-&gt;[FD_COUNT]--;
	   $fe = undef;
	   vec($bits, $fn, 1) = 0;
	   last;
	 }
	 ++$fn;
       }
     }
     else {
       my $i = $fn + FIRST_FD;
       next unless defined $vec-&gt;[$i];
       $vec-&gt;[FD_COUNT]--;
       vec($bits, $fn, 1) = 0;
       $vec-&gt;[$i] = undef;
     }
   }
   $count++;
  }
 $vec-&gt;[VEC_BITS] = $vec-&gt;[FD_COUNT] ? $bits : undef;
 $count;
}

sub can_read
{
 my $vec = shift;
 my $timeout = shift;
 my $r = $vec-&gt;[VEC_BITS];

 defined($r) &amp;&amp; (select($r,undef,undef,$timeout) &gt; 0)
    ? handles($vec, $r)
    : ();
}

sub can_write
{
 my $vec = shift;
 my $timeout = shift;
 my $w = $vec-&gt;[VEC_BITS];

 defined($w) &amp;&amp; (select(undef,$w,undef,$timeout) &gt; 0)
    ? handles($vec, $w)
    : ();
}

sub has_exception
{
 my $vec = shift;
 my $timeout = shift;
 my $e = $vec-&gt;[VEC_BITS];

 defined($e) &amp;&amp; (select(undef,undef,$e,$timeout) &gt; 0)
    ? handles($vec, $e)
    : ();
}

sub has_error
{
 warnings::warn(&quot;Call to deprecated method &#039;has_error&#039;, use &#039;has_exception&#039;&quot;)
	if warnings::enabled();
 goto &amp;has_exception;
}

sub count
{
 my $vec = shift;
 $vec-&gt;[FD_COUNT];
}

sub bits
{
 my $vec = shift;
 $vec-&gt;[VEC_BITS];
}

sub as_string  # for debugging
{
 my $vec = shift;
 my $str = ref($vec) . &quot;: &quot;;
 my $bits = $vec-&gt;bits;
 my $count = $vec-&gt;count;
 $str .= defined($bits) ? unpack(&quot;b*&quot;, $bits) : &quot;undef&quot;;
 $str .= &quot; $count&quot;;
 my @handles = @$vec;
 splice(@handles, 0, FIRST_FD);
 for (@handles) {
     $str .= &quot; &quot; . (defined($_) ? &quot;$_&quot; : &quot;-&quot;);
 }
 $str;
}

sub _max
{
 my($a,$b,$c) = @_;
 $a &gt; $b
    ? $a &gt; $c
        ? $a
        : $c
    : $b &gt; $c
        ? $b
        : $c;
}

sub select
{
 shift
   if defined $_[0] &amp;&amp; !ref($_[0]);

 my($r,$w,$e,$t) = @_;
 my @result = ();

 my $rb = defined $r ? $r-&gt;[VEC_BITS] : undef;
 my $wb = defined $w ? $w-&gt;[VEC_BITS] : undef;
 my $eb = defined $e ? $e-&gt;[VEC_BITS] : undef;

 if(select($rb,$wb,$eb,$t) &gt; 0)
  {
   my @r = ();
   my @w = ();
   my @e = ();
   my $i = _max(defined $r ? scalar(@$r)-1 : 0,
                defined $w ? scalar(@$w)-1 : 0,
                defined $e ? scalar(@$e)-1 : 0);

   for( ; $i &gt;= FIRST_FD ; $i--)
    {
     my $j = $i - FIRST_FD;
     push(@r, $r-&gt;[$i])
        if defined $rb &amp;&amp; defined $r-&gt;[$i] &amp;&amp; vec($rb, $j, 1);
     push(@w, $w-&gt;[$i])
        if defined $wb &amp;&amp; defined $w-&gt;[$i] &amp;&amp; vec($wb, $j, 1);
     push(@e, $e-&gt;[$i])
        if defined $eb &amp;&amp; defined $e-&gt;[$i] &amp;&amp; vec($eb, $j, 1);
    }

   @result = (\@r, \@w, \@e);
  }
 @result;
}


sub handles
{
 my $vec = shift;
 my $bits = shift;
 my @h = ();
 my $i;
 my $max = scalar(@$vec) - 1;

 for ($i = FIRST_FD; $i &lt;= $max; $i++)
  {
   next unless defined $vec-&gt;[$i];
   push(@h, $vec-&gt;[$i])
      if !defined($bits) || vec($bits, $i - FIRST_FD, 1);
  }
 
 @h;
}

1;
__END__

=head1 NAME

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

=head1 SYNOPSIS

    use IO::Select;

    $s = IO::Select-&gt;new();

    $s-&gt;add(\*STDIN);
    $s-&gt;add($some_handle);

    @ready = $s-&gt;can_read($timeout);

    @ready = IO::Select-&gt;new(@handles)-&gt;can_read(0);

=head1 DESCRIPTION

The C&lt;IO::Select&gt; package implements an object approach to the system C&lt;select&gt;
function call. It allows the user to see what IO handles, see L&lt;IO::Handle&gt;,
are ready for reading, writing or have an exception pending.

=head1 CONSTRUCTOR

=over 4

=item new ( [ HANDLES ] )

The constructor creates a new object and optionally initialises it with a set
of handles.

=back

=head1 METHODS

=over 4

=item add ( HANDLES )

Add the list of handles to the C&lt;IO::Select&gt; object. It is these values that
will be returned when an event occurs. C&lt;IO::Select&gt; keeps these values in a
cache which is indexed by the C&lt;fileno&gt; of the handle, so if more than one
handle with the same C&lt;fileno&gt; is specified then only the last one is cached.

Each handle can be an C&lt;IO::Handle&gt; object, an integer or an array
reference where the first element is an C&lt;IO::Handle&gt; or an integer.

=item remove ( HANDLES )

Remove all the given handles from the object. This method also works
by the C&lt;fileno&gt; of the handles. So the exact handles that were added
need not be passed, just handles that have an equivalent C&lt;fileno&gt;

=item exists ( HANDLE )

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

=item handles

Return an array of all registered handles.

=item can_read ( [ TIMEOUT ] )

Return an array of handles that are ready for reading. C&lt;TIMEOUT&gt; is
the maximum amount of time to wait before returning an empty list, in
seconds, possibly fractional. If C&lt;TIMEOUT&gt; is not given and any
handles are registered then the call will block.

=item can_write ( [ TIMEOUT ] )

Same as C&lt;can_read&gt; except check for handles that can be written to.

=item has_exception ( [ TIMEOUT ] )

Same as C&lt;can_read&gt; except check for handles that have an exception
condition, for example pending out-of-band data.

=item count ()

Returns the number of handles that the object will check for when
one of the C&lt;can_&gt; methods is called or the object is passed to
the C&lt;select&gt; static method.

=item bits()

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

=item select ( READ, WRITE, EXCEPTION [, TIMEOUT ] )

C&lt;select&gt; is a static method, that is you call it with the package name
like C&lt;new&gt;. C&lt;READ&gt;, C&lt;WRITE&gt; and C&lt;EXCEPTION&gt; are either C&lt;undef&gt; or
C&lt;IO::Select&gt; objects. C&lt;TIMEOUT&gt; is optional and has the same effect as
for the core select call.

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

=back

=head1 EXAMPLE

Here is a short example which shows how C&lt;IO::Select&gt; 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 = IO::Socket::INET-&gt;new(Listen =&gt; 1, LocalPort =&gt; 8080);
    $sel = IO::Select-&gt;new( $lsn );

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

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

=head1 AUTHOR

Graham Barr. Currently maintained by the Perl Porters.  Please report all
bugs to &lt;perlbug@perl.org&gt;.

=head1 COPYRIGHT

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

=cut

</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>