File Coverage

blib/lib/ONE/Timer.pm

Criterion	Covered	Total	%
statement	68	75	90.6
branch	11	16	68.7
condition			n/a
subroutine	16	18	88.8
pod	7	7	100.0
total	102	116	87.9

package ONE::Timer;
{
  $ONE::Timer::VERSION = 'v0.2.0';
}
# Dist::Zilla: +PodWeaver
# ABSTRACT: Timer/timeout events for MooseX::Event
use AnyEvent ();
use MooseX::Event;
use Scalar::Util ();

has 'delay'    => (isa=>'Num|CodeRef', is=>'ro', default=>0);


has 'interval' => (isa=>'Num', is=>'ro', default=>0);

has '_guard'   => (is=>'rw');


has_event 'timeout';

no MooseX::Event; # Remove the moose helpers, so we can declare our own after method

use Exporter;
*import = \&Exporter::import;

our @EXPORT_OK = qw( sleep sleep_until );


sub sleep {
    return if $_[-1] <= 0;
    my $cv = AE::cv;
    my $w; $w=AE::timer( $_[-1], 0, sub { undef $w; $cv->send } );
    $cv->recv;
}


sub sleep_until {
    my $for = $_[-1] - AE::time;
    return if $for <= 0;
    my $cv = AE::cv;
    my $w; $w=AE::timer( $for, 0, sub { undef $w; $cv->send } );
    $cv->recv;
}


sub after {
    my $class = shift;
    my( $after, $on_timeout ) = @_;
    my $self = $class->new( delay=> $after );
    $self->on( timeout => $on_timeout );
    $self->start( defined(wantarray) );
    return $self;
}


sub at {
    my $class = shift;
    my( $at, $on_timeout ) = @_;
    my $self = $class->new( delay=> sub {$at - AE::time}  );
    $self->on( timeout => $on_timeout );
    $self->start( defined(wantarray) );
    return $self;
}


sub every {
    my $class = shift;
    my( $every, $on_timeout ) = @_;
    my $self = $class->new( delay => $every, interval => $every );
    $self->on( timeout => $on_timeout );
    $self->start( defined(wantarray) );
    return $self;
}


sub start {
    my $self = shift;
    my( $is_weak ) = @_;

    if ( defined $self->_guard ) {
        require Carp;
        Carp::croak( "Can't start a timer that's already running" );
    }

    my $cb;
    Scalar::Util::weaken($self) if $is_weak;
    if ( $self->interval ) {
        $cb = sub { $self->emit('timeout') };
    }
    else {
        $cb = sub { $self->cancel; $self->emit('timeout'); }
    }
    my $delay;
    if ( ref $self->delay ) {
        $delay = $self->delay->();
        $delay = 0 if $delay < 0;
    }
    else {
        $delay = $self->delay;
    }
    my $w = AE::timer $delay, $self->interval, sub { $self->emit('timeout') };
    $self->_guard( $w );
}


sub cancel {
    my $self = shift;
    unless (defined $self->_guard) {
        require Carp;
        Carp::croak( "Can't cancel a timer that's not running" );
    }
    $self->_guard( undef );
}


__PACKAGE__->meta->make_immutable();

1;


__END__