File Coverage

lib/Set/CartesianProduct/Lazy.pm

Criterion	Covered	Total	%
statement	61	61	100.0
branch	6	10	60.0
condition			n/a
subroutine	16	16	100.0
pod	4	4	100.0
total	87	91	95.6

use strict;
use warnings;
package Set::CartesianProduct::Lazy;
$Set::CartesianProduct::Lazy::VERSION = '0.004';
{
  $Set::CartesianProduct::Lazy::DIST = 'Set-CartesianProduct-Lazy';
}

# ABSTRACT: lazily calculate the tuples of a cartesian-product

use List::Util qw( reduce );
use Scalar::Util qw( reftype );
use Data::Dumper;
use Carp;

sub new {
  my $class = shift;
  my %opts = map { %$_ } grep { reftype $_ eq 'HASH' } @_;
  my @sets = grep { reftype $_ eq 'ARRAY' } @_;

  my $getsub = __make_getsub(\%opts, \@sets);

  return bless { %opts, sets => \@sets, getsub => $getsub }, $class;
}

sub __make_getsub {
  my ($opts, $sets_ref) = @_;

  # TODO: eval code to produce the sub so the code isn't duplicated

  if ($opts->{less_lazy}) {

    # pre-calculate some things, so we don't have to every time.
    my @sets = @$sets_ref;
    my @info = map {
      [ $_, (scalar @{$sets[$_]}), reduce { $a * @$b } 1, @sets[$_ + 1 .. $#sets] ];
    } 0 .. $#sets;

    return sub {
      my ($n) = @_;

      my @tuple = map {
        my ($set_num, $set_size, $factor) = @$_;
        $sets[ $set_num ][ int( $n / $factor ) % $set_size ];
      } @info;

      return wantarray ? @tuple : \@tuple;
    };
  }

  return sub {
    my ($n) = @_;

    my @tuple;

    my @sets = @$sets_ref;

    for my $set_num (0 .. $#sets) {
      my $set_size = @{ $sets[$set_num] };
      my $factor   = reduce { $a * @$b } 1, @sets[$set_num + 1 .. $#sets];
      my $idx      = int( $n / $factor ) % $set_size;

      push @tuple, $sets[$set_num][$idx];
    }

    return wantarray ? @tuple : \@tuple;
  };
}


sub get {
  my $self = shift;
  croak "no value passed to get method\n" unless defined $_[0];
  $self->{getsub}->(@_);
}


#sub get_faster { my $self = shift; $self->{getsub}->(@_); }

{
  no warnings 'once';
  sub count { return reduce { $a * @$b } 1, @{ shift->{sets} || [] } }
}

sub last_idx { return shift->count - 1 }


1 && q{a set in time saves nine};

__END__