File Coverage

blib/lib/IO/Mux/Select.pm

Criterion	Covered	Total	%
statement	100	100	100.0
branch	25	28	89.2
condition	5	6	83.3
subroutine	15	15	100.0
pod	2	7	28.5
total	147	156	94.2

package IO::Mux::Select ;

use strict ;
use IO::Select ;
use IO::Mux ;
use IO::Mux::Handle ;
use IO::Mux::Packet ;
use Carp ;


our $VERSION = '0.08' ;


sub new {
	my $class = shift ;

	my $this = {} ;
	$this->{'select'} = new IO::Select() ;
	$this->{mux_handles} = {} ;
	bless($this, $class) ;

	$this->add(@_) ;

	return $this ;
}


sub _get_select {
	my $this = shift ;

	return $this->{'select'} ;
}


sub _get_mux_handles {
	my $this = shift ;

	return $this->{mux_handles} ;
}


sub add {
	my $this = shift ;

	foreach my $h (@_){
		if ($h->isa('IO::Mux::Handle')){
			$this->_get_mux_handles()->{$h->_get_tie()->_get_id()} = $h ;
		}
		else {
			$this->_get_select()->add($h) ;
		}
	}
}


sub remove {
	my $this = shift ;

	foreach my $h (@_){
		if ($h->isa('IO::Mux::Handle')){
			delete $this->_get_mux_handles()->{$h->_get_tie()->_get_id()} ;
		}
		elsif ($this->_get_select()->exists($h)){
			$this->_get_select()->remove($h) ;
		}
	}
}


sub exists {
	my $this = shift ;
	my $h = shift ;

	if ($h->isa('IO::Mux::Handle')){
		return $this->_get_mux_handles()->{$h->_get_tie()->_get_id()} ;
	}
	else {
		return $this->_get_select()->exists($h) ;
	}
}


sub handles {
	my $this = shift ;

	my @ret = () ;
	push @ret, values %{$this->_get_mux_handles()} ;
	push @ret, $this->_get_select()->handles() ;

	return @ret ;
}


sub count {
	my $this = shift ;

	return scalar($this->handles()) ;
}


sub can_read {
	my $this = shift ;
	my $timeout = shift ;

	# First, we will check to see if the IO::Mux::Handles have data in their buffers.
	my @ready = () ;
	foreach my $h (values %{$this->_get_mux_handles()}){
		if ((eof($h))||($h->_get_tie()->_get_buffer()->get_length() > 0)){
			push @ready, $h ;
		}
	}

	if (scalar(@ready)){
		# Maybe some real handles are immediately ready
		push @ready, $this->_get_select()->can_read(0) ;
		return @ready ;
	}

	# So it seems we may have to wait after all. We now need to build a list
	# of all the REAL handles underneath all the IO::Mux::Handles.
	my %mux_objects = () ;
	foreach my $h (values %{$this->_get_mux_handles()}){
		my $mux = $h->_get_tie()->_get_mux() ;
		my $rh = $mux->_get_handle() ;
		if (! exists($mux_objects{$rh})){
			$mux_objects{$rh} = {mux => $mux, mux_handles => {}} ;
		}
		$mux_objects{$rh}->{mux_handles}->{$h} = $h ;
	}

	my @real_handles = map {$_->{mux}->_get_handle()} values(%mux_objects) ;
	$this->_get_select()->add(@real_handles) ;
	@ready = $this->_get_select()->can_read($timeout) ;
	$this->_get_select()->remove(@real_handles) ;

	if (scalar(@ready)){
		my @tmp = @ready ;
		my %ready = () ;
		@ready = () ;
		foreach my $h (@tmp){
			my $mux_data = $mux_objects{$h} ;
			if ($mux_data){
				my $mux = $mux_data->{mux} ;
				# We have data ready on the REAL handle. Let's consume the packet
				# and add the corresponding IO::Mux::Handle in the new ready list.
				while ((my $p = $mux->_read_packet(0)) != -1){
					if ((! defined($p))||(! $p)){
						# ERROR or EOF on the real handle. Return all mux_handles
						# as they all now are at EOF or have an error state.
						foreach my $mh (values %{$mux_data->{mux_handles}}){
							if (! $ready{$mh}){
								push @ready, $mh ;
								$ready{$mh} = 1 ;
							}
						}
						last ;
					}
					else {
						my $mh = $this->_get_mux_handles()->{$p->get_id()} ;
						next unless defined($mh) ;
						if (! $ready{$mh}){
							push @ready, $mh ;
							if ($p->is_eof()){
								$mh->_get_tie()->_set_eof() ;
							}
							$ready{$mh} = 1 ;
						}
					}
				}
			}
			else {
				# REAL handle, we simply push it.
				push @ready, $h ;
			}
		}
	}

	return @ready ;
}


1 ;
__END__