File Coverage

blib/lib/Net/OnlineCode/Decoder.pm

Criterion	Covered	Total	%
statement	18	46	39.1
branch	0	8	0.0
condition			n/a
subroutine	6	9	66.6
pod	1	3	33.3
total	25	66	37.8

package Net::OnlineCode::Decoder;

use strict;
use warnings;

use Carp;

use Net::OnlineCode;
use Net::OnlineCode::GraphDecoder;

use vars qw(@ISA @EXPORT_OK %EXPORT_TAGS $VERSION);

require Exporter;

# Inherit from base class
@ISA = qw(Net::OnlineCode Exporter);
@EXPORT_OK = qw();

$VERSION = '0.02';

sub new {

  my $class = shift;

  my %opts = (
	      # decoder-specific arguments:
	      initial_rng => undef,
	      # user-supplied arguments:
	      @_
	     );
  unless (ref($opts{initial_rng})) {
    carp "$class->new requires an initial_rng => \$rng parameter\n";
    return undef;
  }

  # Send all arguments to the base class. It does basic parameter
  # handling/mangling, calculates the number of auxiliary blocks based
  # on them and generates a probability distribution.

  my $self = $class->SUPER::new(@_);

  # This sub-class needs to use the rng to generate the initial graph

  # print "decoder mblocks: $self->{mblocks}\n";

  my $graph = Net::OnlineCode::GraphDecoder->new
    (
     $self->{mblocks},
     $self->{ablocks},
     $self->auxiliary_mapping($opts{initial_rng}),
     $self->{expand_aux},
    );
  $self->{graph} = $graph;

  # print "Decoder: returning from constructor\n";
  return $self;

}

sub accept_check_block {
  my $self = shift;
  my $rng  = shift;

  # print "Decoder: calling checkblock_mapping\n";
  my $composite_blocks = $self->checkblock_mapping($rng);

  # print "Decoder: Adding check block to graph\n";
  my $check_node = $self->{graph}->add_check_block($composite_blocks);

  # short-circuit check blocks that don't have any unsolved neighbours
  return (0) unless $check_node;

  # print "Decoder: Resolving graph\n";
  my ($done, @which) = ($self->{graph}->resolve($check_node));

  # print "Decoder: Returning from accept_check_block\n";
  if ($self->{expand_aux}) {
    # user doesn't care about aux blocks if expand_aux is on
    return ($done, grep { $_ < $self->{mblocks} } @which );
  } else {
    return ($done, @which);
  }
}

# expand_aux already handled in graph object
sub xor_list {
  my $self = shift;
  my $i = shift;

  return ($self->{graph}->xor_list($i));

  # algorithm will no longer return just composite blocks


  my $coblocks = $self->get_coblocks;

  # the graph object assigns check blocks indexes after the composite
  # blocks, but the user would prefer to count them from zero:

  my @list = map { $_ - $coblocks } ($self->{graph}->xor_list($i));

  foreach (@list) { die "xor_list: $_ is negative!\n" if $_ < 0; }

  return @list;
}

1;

__END__