File Coverage

blib/lib/Convert/yEnc/Entry.pm

Criterion	Covered	Total	%
statement	102	102	100.0
branch	26	36	72.2
condition	11	16	68.7
subroutine	26	26	100.0
pod	2	2	100.0
total	167	182	91.7

package Convert::yEnc::Entry;

use strict;
use Set::IntSpan;
use warnings;

sub new
{
    my($class, $fields) = @_;

    $fields->{part} ?
	new Convert::yEnc::EntryM $fields :
	new Convert::yEnc::EntryS $fields
}

sub load
{
    my($class, $line) = @_;

    my($size, $bytes, $parts) = split "\t", $line;

    $parts ?
	load Convert::yEnc::EntryM $size, $bytes, $parts :
	load Convert::yEnc::EntryS $size, $bytes
}


package Convert::yEnc::EntryS;

use base qw(Convert::yEnc::Entry);

use overload '""' => \&to_string,
             'eq' => \&_eq;



sub new
{
    my($class, $fields) = @_;

    my $size = $fields->{size};
    $size or return undef;

    my $entry = { state => 'ybegin',
		  size  => $size,
	          bytes => 0       };

    bless $entry, $class
}

sub load
{
    my($class, $size, $bytes) = @_;

    my $entry = { state => 'yend',
		  size  => $size,
		  bytes => $bytes };

    bless $entry, $class
}


sub ybegin { 0 }
sub ypart  { 0 }

sub yend
{
    my($entry, $fields) = @_;

    $entry->{state} eq 'ybegin' or return 0;
    $entry->{state} =  'yend';

    my $size = $fields->{size};
    $entry->{bytes} = $size;
    $size and $size == $entry->{size}
}

sub complete
{
    my $entry = shift;

    $entry->{state} eq 'yend'
}


sub to_string
{
    my $entry = shift;
    my $size  = $entry->{size}  || 0;
    my $bytes = $entry->{bytes} || 0;

    "$size\t$bytes"
}

sub _eq
{
    no warnings qw(uninitialized);

    my($a, $b) = $_;

    $a->{size }==$b->{size } and
    $a->{bytes}==$b->{bytes}
}


package Convert::yEnc::EntryM;

use base qw(Convert::yEnc::Entry);

use overload '""' => \&to_string,
             'eq' => \&_eq;



sub new
{
    my($class, $fields) = @_;

    defined $fields->{size} or return undef;

    my $entry = { state => 'ybegin',
		  fSize => $fields->{size},
		  part  => $fields->{part},
		  total => $fields->{total},
		  parts => (new Set::IntSpan),
		  bytes => (new Set::IntSpan)  };

    bless $entry, $class
}

sub load
{
    my($class, $size, $bytes, $parts) = @_;

    my $entry = { state => 'yend',
		  fSize => $size,
		  bytes => (new Set::IntSpan $bytes),
		  parts => (new Set::IntSpan $parts) };

    bless $entry, $class
}

sub ypart
{
    my($entry, $fields) = @_;

    $entry->{state} eq 'ybegin' or return 0;
    $entry->{state} =  'ypart';

    my $begin = $fields->{begin};
    my $end   = $fields->{end  };
    $begin and $end or return 0;

    $entry->{begin} = $begin;
    $entry->{end  } = $end;

    $entry->{pSize} = $end - $begin + 1;
}

sub yend
{
    my($entry, $fields) = @_;

    $entry->{state} eq 'ypart' or return 0;
    $entry->{state} =  'yend';

    my $pSize = $fields->{size};
    defined $pSize or return 0;

    my $part = $fields->{part};
    $part == $entry->{part} or return 0;

    $entry->{parts}->insert($part);

    my $begin = $entry->{begin};
    my $end   = $entry->{end  };
    my $bytes = "$begin-$end";

    valid Set::IntSpan $bytes or return 0;
    $entry->{bytes} = $entry->{bytes}->union($bytes);

    1
}

sub ybegin
{
    my($entry, $fields) = @_;

    $entry->{state} eq 'yend' or return 0;
    $entry->{state} =  'ybegin';

    $fields->{size}==$entry->{fSize} or return 0;

    my $total = $fields->{total};
    defined $total and defined $entry->{total} and $total != $entry->{total} and
	return 0;

    my $part  = $fields->{part};
    defined $part or return 0;
    $entry->{part} = $part;

    1
}

sub complete
{
    my $entry = shift;

    $entry->{fSize} == $entry->{bytes}->cardinality;
}


sub to_string
{
    my $entry = shift;
    my $size  = $entry->{fSize};
    my $bytes = $entry->{bytes}->run_list;
    my $parts = $entry->{parts}->run_list;

    "$size\t$bytes\t$parts"
}


sub _eq
{
    my($a, $b) = @_;

    $a->{fSize}==$b->{fSize}        and
    $a->{bytes}->equal($b->{bytes}) and
    $a->{parts}->equal($b->{parts})
}


1

__END__