File Coverage

lib/Functional/Iterator.pm

Criterion	Covered	Total	%
statement	40	40	100.0
branch	18	18	100.0
condition			n/a
subroutine	7	7	100.0
pod	4	4	100.0
total	69	69	100.0

use strict;
use warnings;

package Functional::Iterator;
use base qw(Exporter);

our @EXPORT = qw(iterator);

our $VERSION = 1.05;

sub iterator { __PACKAGE__->new(@_) }

sub new {
  my ($class, %args) = @_;
  return bless +{
    %args,
    index => 0,
  }, $class;
}

sub next {
  my ($self) = @_;

  my $record;
  my $index = $self->{index};

  if (exists $self->{generated_record}) {
    # If the previous call to ->next() yielded an iterator, then we stashed that
    # iterator into $self->{generated_record} and returned that stashed iterator's
    # ->next record. Now it's time to ask that stashed previously-generated-but
    # now-active iterator for another record.
    $record = delete $self->{generated_record};
  } elsif (exists $self->{generator}) {
    # We have no current stashed iterator: either our generator doesn't produce
    # iterators, or the last iterator it produced has been exhausted.
    $record = $self->{generator}->();
  } else {
    # Oh, we're just a simple iterator over records, how nice.
    $record = $self->{records}[$index];
  }

  if (UNIVERSAL::isa($record, ref($self))) {
    $self->{generated_record} = $record      # The putative $record is actually an iterator, so stash it away...
      if exists $self->{generator};          # ...(maybe)...
    $record = $record->next;                 # ...and ask it for its next record.

    if (! defined($record)) {                      # Whoops, the stashed-away iterator is exhausted...
      if (exists $self->{records}[$index + 1]) {   # Simple iterator-over-records case
        $self->{index}++;
        return $self->next;
      } else {                                     # Oh, there's no next record available: why not?
        if (exists $self->{generator}) {           # ...because we're an iterator over generated iterators.
          delete $self->{generated_record};        #    ...Okay, discard this iterator (it's clearly exhausted)
          return $self->next;                      #    ...and ask myself for another
        } else {                                   # ...because we're an iterator over records
          return undef;                            #    ...but there is no next record, so signal exhaustion
        }
      }
    }
  } else {
    $self->{index}++;
  }
  return undef unless defined $record;

  return $self->{mutator}
    ? $self->{mutator}->($record)
    : $record;
}

sub reset {
  my ($self) = @_;
  $self->{index} = 0;
  delete $self->{generated_record};
  foreach (grep { UNIVERSAL::isa($_, __PACKAGE__) } @{$self->{records}}) {
    $_->reset;
  }
}

1;

__END__