Future-Q

 view release on metacpan or  search on metacpan

lib/Future/Q.pm  view on Meta::CPAN

package Future::Q;
use strict;
use warnings;
use Future 0.29;
use parent "Future";
use Devel::GlobalDestruction;
use Scalar::Util qw(refaddr blessed weaken);
use Carp;
use Try::Tiny ();

our $VERSION = '0.120';

our @CARP_NOT = qw(Try::Tiny Future Future::PP Future::XS);

our $OnError = undef;

## ** lexical attributes to avoid collision of names.

lib/Future/Q.pm  view on Meta::CPAN

        }
        my $return_future = $invo_future;
        if($invo_future->is_rejected && defined($on_rejected)) {
            $return_future = $class->try($on_rejected, $invo_future->failure);
        }elsif($invo_future->is_fulfilled && defined($on_fulfilled)) {
            $return_future = $class->try($on_fulfilled, $invo_future->get);
        }
        $next_future->resolve($return_future);
    });
    if($next_future->is_pending && $self->is_pending) {
        weaken(my $invo_future = $self);
        $next_future->on_cancel(sub {
            if(defined($invo_future) && $invo_future->is_pending) {
                $invo_future->cancel();
            }
        });
    }
    return $next_future;
}

sub catch {

lib/Future/Q.pm  view on Meta::CPAN

        }elsif($base_future->failure) {
            if($base_future->can("_q_set_failure_handled")) {
                $base_future->_q_set_failure_handled();
            }
            $self->reject($base_future->failure);
        }else {
            $self->fulfill($base_future->get);
        }
    });
    if(!$base_future->is_ready) {
        weaken(my $weak_base = $base_future);
        $self->on_cancel(sub {
            $weak_base->cancel() if defined($weak_base) && !$weak_base->is_ready;
        });
    }
    return $self;
}

sub reject {
    goto $_[0]->can('fail');
}

lib/Future/Q.pm  view on Meta::CPAN

        my $returned_future = $class->try($callback);
        $returned_future->on_ready(sub {
            my ($returned_future) = @_;
            if(!$returned_future->is_cancelled && $returned_future->failure) {
                $next_future->resolve($returned_future);
            }else {
                $next_future->resolve($invo_future);
            }
        });
        if(!$returned_future->is_ready) {
            weaken(my $weak_returned = $returned_future);
            $next_future->on_cancel(sub {
                $weak_returned->cancel if defined($weak_returned) && !$weak_returned->is_ready;
            });
        }
    });
    if(!$self->is_ready) {
        weaken(my $weak_invo = $self);
        $next_future->on_cancel(sub {
            $weak_invo->cancel if defined($weak_invo) && !$weak_invo->is_ready;
        
        });
    }
    return $next_future;
}

1;