File Coverage

blib/lib/AnyEvent/Digest.pm

Criterion	Covered	Total	%
statement	79	95	83.1
branch	23	26	88.4
condition	5	8	62.5
subroutine	18	24	75.0
pod	6	6	100.0
total	131	159	82.3

package AnyEvent::Digest;

use strict;
use warnings;

# ABSTRACT: A tiny AnyEvent wrapper for Digest::*
our $VERSION = 'v0.0.5'; # VERSION

use Carp;
use AnyEvent;
use Scalar::Util qw(refaddr);

my $AIO_DISABLED;
eval 'use AnyEvent::AIO';
$AIO_DISABLED = 1 if $@;
eval 'use IO::AIO';
$AIO_DISABLED = 1 if $@;

# Most methods are falled back to Digest
our $AUTOLOAD;
sub AUTOLOAD
{
    my $self = shift;
    my $called = $AUTOLOAD;
    $called =~ s/.*:://;
    croak "AnyEvent::Digest: Unknown method `$called' is called for `".ref($self->{base})."'" unless $self->{base}->can($called);
    $self->{base}->$called(@_);
}

sub DESTROY {}

sub _by_idle
{
    my ($self, $cv, $work) = @_;
    my $call; $call = sub {
        if($work->()) {
            my $w; $w = AE::idle sub {
                undef $w;
                $call->();
            };
        } else {
            undef $call;
            $cv->send($self);
        }
    };
    $call->();
}

sub _file_by_idle
{
    my ($self, $cv, $fh, $work) = @_;
    $self->_by_idle($cv, sub {
        my $ret = read $fh, my $dat, $self->{unit};
        return $cv->croak("AnyEvent::Digest: Read error occurs") unless defined($ret);
        return $work->($dat);
    });
}

sub _file_by_aio
{
    my ($self, $cv, $fh, $work) = @_;
#    my $size = 0;
    my $call; $call = sub {
        my $dat = ''; # If not initialized, "Use of uninitialized value in subroutine entry" issued.
        IO::AIO::aio_read($fh, undef, $self->{unit}, $dat, 0, sub {
            return $cv->croak("AnyEvent::Digest: Read error occurs") if $_[0] < 0;
#            $size += $_[0];
            if($work->($dat)) {
#print STDERR "0: $size $_[0] ",length($dat),"\n";
                $call->();
            } else {
#print STDERR "1: $size $_[0] ",length($dat),"\n";
                undef $call;
                $cv->send($self);
            }
        });
    };
    $call->();
}

my %dispatch = (
    idle => \&_file_by_idle,
    aio => \&_file_by_aio,
);

sub _dispatch
{
    my $method = $dispatch{$_[0]->{backend}};
    croak "AnyEvent::Digest: Unknown backend `$_[0]->{backend}' is specified" unless defined $method;
    return $method->(@_);
}

sub new
{
    my ($class, $base, %args) = @_;
    $class = ref $class || $class;
    $args{unit} ||= 65536;
    $args{backend} = 'idle' unless defined $args{backend};
    croak "AnyEvent::Digest: `aio' backend requires `IO::AIO' and `AnyEvent::AIO'" if $args{backend} eq 'aio' && $AIO_DISABLED;
    croak "AnyEvent::Digest: Unknown backend `$args{backend}' is specified" unless exists $dispatch{$args{backend}};
    eval "require $base" or croak "AnyEvent::Digest: Unknown base digest module `$base' is specified";
    return bless {
        base => $base->new(@{$args{opts}}),
        map { $_, $args{$_} } qw(backend unit),
    }, $class;
}

sub add_async
{
    my $self = shift;
    my $cv = AE::cv;
    my (@dat) = @_;
    $self->_by_idle($cv, sub {
        my $dat = shift @dat;
        $self->{base}->add($dat);
        return scalar @dat;
    });
    return $cv;
}

sub addfile_async
{
    my ($self, $target, $mode) = @_;
    my $cv = AE::cv;
    my $fh;
    if(ref $target) {
        $fh = $target;
    } else {
        open $fh, '<:raw', $target or croak "AnyEvent::Digest: Open error occurs for `$target'";
    }
    $self->_dispatch($cv, $fh, sub {
        my $dat = shift;
        if(! length $dat) {
            close $fh;
            return;
        }
        $self->{base}->add($dat);
    });
    return $cv;
}

sub addfile
{
    return shift->addfile_async(@_)->recv;
}

sub addfile_base
{
    return shift->{base}->addfile(@_);
}

sub add_bits_async
{
    my $self = shift;
    my $cv = AE::cv;
    $self->{base}->add_bits(@_);
    $cv->send($self);
    return $cv;
}

1;

__END__