File Coverage

blib/lib/Async/Selector/Watcher.pm

Criterion	Covered	Total	%
statement	36	36	100.0
branch	2	2	100.0
condition			n/a
subroutine	12	12	100.0
pod	4	8	50.0
total	54	58	93.1

package Async::Selector::Watcher;
use strict;
use warnings;
use Scalar::Util qw(weaken);
use Carp;

sub new {
    my ($class, $selector, $conditions) = @_;
    my $self = bless {
        selector => $selector,
        conditions => $conditions,
        check_all => 0,
    }, $class;
    weaken($self->{selector});
    return $self;
}

sub detach {
    my ($self) = @_;
    $self->{selector} = undef;
}

sub get_check_all {
    my ($self) = @_;
    return $self->{check_all};
}

sub set_check_all {
    my ($self, $check_all) = @_;
    $self->{check_all} = $check_all;
}

sub cancel {
    my ($self) = @_;
    return $self if not defined($self->{selector});
    my $selector = $self->{selector};
    $self->detach();
    $selector->cancel($self);
    return $self;
}

sub conditions {
    my ($self) = @_;
    return %{$self->{conditions}};
}

sub resources {
    my ($self) = @_;
    return keys %{$self->{conditions}};
}

sub active {
    my ($self) = @_;
    return defined($self->{selector});
}

our $VERSION = '1.03';

1;

=pod

=head1 NAME

Async::Selector::Watcher - representation of resource watch in Async::Selector

=head1 VERSION

1.03

=head1 SYNOPSIS


    use Async::Selector;

    my $s = Async::Selector->new();

    setup_resources_with($s);

    ## Obtain a watcher from Selector.
    my $watcher = $s->watch(a => 1, b => 2, sub {
        my ($w, %res) = @_;
        handle_a($res{a}) if exists $res{a};
        handle_b($res{b}) if exists $res{b};
    });

    ## Is the watcher active?
    $watcher->active;                          ## => true

    ## Get the list of watched resources
    my @resources = sort $watcher->resources;  ## => ('a', 'b')

    ## Get the watcher conditions
    my %conditions = $watcher->conditions;     ## => (a => 1, b => 2)

    ## Cancel the watcher
    $watcher->cancel;


=head1 DESCRIPTION

L is an object that stores information about a resource watch in L module.
It also provides its user with a way to cancel the watch.


=head1 CLASS METHODS

Nothing.

L objects are created by C, C and C methods of L.


=head1 OBJECT METHODS

In the following description, C<$watcher> is an L object.

=head2 $is_active = $watcher->active();

Returns true if the L is active. Returns false otherwise.

Active watchers are the ones in L objects, watching some of the Selector's resources.
Callback functions of active watchers can be executed if the watched resources get available.

Inactive watchers are the ones that have been removed from L objects.
Their callback functions are never executed any more.

Note that watchers are automatically canceled and become inactive when their parent L object is destroyed.


=head2 $watcher->cancel();

Cancels the watch.

The C<$watcher> then becomes inactive and is removed from the L object it used to belong to.


=head2 @resources = $watcher->resources();

Returns the list of resource names that are watched by this L object.



=head2 %conditions = $watcher->conditions();

Returns a hash whose keys are the resource names that are watched by this L object,
and values are the condition inputs for the resources.



=head1 SEE ALSO

L


=head1 AUTHOR

Toshio Ito, C<<  >>

=head1 LICENSE AND COPYRIGHT

Copyright 2012-2013 Toshio Ito.

This program is free software; you can redistribute it and/or modify it
under the terms of either: the GNU General Public License as published
by the Free Software Foundation; or the Artistic License.

See http://dev.perl.org/licenses/ for more information.



=cut