File Coverage

blib/lib/Mock/Data/Set.pm

Criterion	Covered	Total	%
statement	69	89	77.5
branch	23	46	50.0
condition	16	32	50.0
subroutine	13	14	92.8
pod	7	7	100.0
total	128	188	68.0

package Mock::Data::Set;
use strict;
use warnings;
require Mock::Data::Generator;
our @ISA= qw( Mock::Data::Generator );

# ABSTRACT: Generator which returns one item from a set
our $VERSION = '0.01'; # VERSION


sub new {
	my $class= shift;
	my %args= @_ == 1 && ref $_[0] eq 'HASH'? %{$_[0]}
		: @_ == 1 && ref $_[0] eq 'ARRAY'? ( items => $_[0] )
		: @_;
	bless \%args, $class;
}

sub new_weighted {
	my $class= shift;
	@_ & 1 and Carp::croak("Odd number of elements given to new_weighted, need (value => weight) pairs");
	my (@items, @weights);
	while (@_) {
		push @items, shift;
		push @weights, shift;
	}
	$class->new(items => \@items, weights => \@weights);
}


sub items {
	my $self= shift;
	return $self->{items} unless @_;
	my $val= shift;
	delete $self->{_odds_table} if $#{$self->{items}} != $#$val;
	return $self->{items}= $val;
}

sub weights {
	my $self= shift;
	return $self->{weights} unless @_;
	delete $self->{_odds_table};
	return $self->{weights}= shift;
}


sub generate {
	my $self= shift;
	my $items= $self->items;
	my $pick;
	if (!$self->weights) {
		$pick= rand( scalar @$items );
	} else {
		# binary search for the random number
		my $tbl= $self->_odds_table;
		my ($min, $max, $r)= (0, $#$items, rand);
		while ($min+1 < $max) {
			my $mid= int(($max+$min)/2);
			if ($r < $tbl->[$mid]) { $max= $mid-1; }
			else { $min= $mid; }
		}
		$pick= ($max > $min && $tbl->[$max] <= $r)? $max : $min;
	}
	my $cmp_item= $items->[$pick];
	return $cmp_item unless ref $cmp_item && ref($cmp_item)->can('generate');
	$cmp_item->generate(@_);
}

sub _odds_table {
	$_[0]{_odds_table} ||= $_[0]->_build__odds_table;
}

sub _build__odds_table {
	my $self= shift;
	my $items= $self->items;
	my $weights= $self->weights;
	my $total= 0;
	$total += ($weights->[$_] ||= 1)
		for 0..$#$items;
	my $sum= 0;
	return [ map { my $x= $sum; $sum += $_; $x/$total } @$weights ]
}


sub compile {
	my $self= shift;
	my $items= $self->items;
	my @compiled;
	for (@$items) {
		if (ref && ref->can('generate')) {
			# Some items are generators.  Compile a list of them, but only the generators.
			@compiled= map +(ref && ref->can('generate')? $_->compile : undef), @$items;
			last;
		}
	}

	if (!$self->weights) {
		return !@compiled
			? sub { $items->[int rand scalar @$items] }
			: sub {
				my $pick= int rand scalar @$items;
				$compiled[$pick]? $compiled[$pick]->(@_) : $items->[$pick];
			};
	}
	else {
		my $odds_table= $self->_odds_table;
		return sub {
			# binary search for the random number
			my ($min, $max, $r)= (0, $#$items, rand);
			while ($min+1 < $max) {
				my $mid= int(($max+$min)/2);
				if ($r < $odds_table->[$mid]) { $max= $mid-1; }
				else { $min= $mid; }
			}
			my $pick= ($max > $min && $odds_table->[$max] <= $r)? $max : $min;
			$compiled[$pick]? $compiled[$pick]->(@_) : $items->[$pick];
		}
	}
}


sub combine_generator {
	my ($self, $peer)= @_;
	my @items= @{$self->items};
	my $weights= $self->weights;
	if ($peer->isa('Mock::Data::Set')) {
		my $peer_items= $peer->items;
		my $peer_weights= $peer->weights;
		if ($weights || $peer_weights) {
			$weights= [
				$weights?      @$weights      : (map 1, @items),
				$peer_weights? @$peer_weights : (map 1, @$peer_items),
			];
		}
		push @items, @$peer_items;
	} else {
		push @items, $peer;
		$weights= $weights && @$weights? [ @$weights, List::Util::sum0(@$weights)/@$weights ] : undef;
	}
	return Mock::Data::Set->new(
		items => \@items,
		weights => $weights,
	);
}

require Mock::Data::Util;

__END__