File Coverage

blib/lib/Iterator/Flex/Stack.pm

Criterion	Covered	Total	%
statement	76	80	95.0
branch	11	16	68.7
condition	2	3	66.6
subroutine	20	20	100.0
pod	1	1	100.0
total	110	120	91.6

package Iterator::Flex::Stack;

# ABSTRACT: An iterator which concatenates a set of iterators

use v5.28;
use strict;
use warnings;
use experimental qw( signatures declared_refs refaliasing );

our $VERSION = '0.33';

use Iterator::Flex::Utils qw( RETURN STATE EXHAUSTION :IterAttrs :IterStates );
use Iterator::Flex::Factory 'to_iterator';
use parent 'Iterator::Flex::Base';
use List::Util 'all';

use namespace::clean;

















































sub new ( $class, @args ) {
    my $pars = Ref::Util::is_hashref( $args[-1] ) ? pop @args : {};

    $class->SUPER::new( {
            depends                => \@args,
            current_iterator_index => undef,
        },
        $pars,
    );
}

sub construct ( $class, $state ) {
    throw_failure( parameter => q{state must be a HASH reference} )
      unless Ref::Util::is_hashref( $state );

    $state->{value} //= [];

    my ( \@depends, $prev, $current, undef, undef )
      = @{$state}{ 'depends', 'prev', 'current', 'next', 'thaw' };

    # transform into iterators if required.
    my @stack
      = map { to_iterator( $_, { ( +EXHAUSTION ) => RETURN } ) } @depends;
    my @snapshot = @stack;

    # --- cargo cult??
    # my $value;
    # $value = $current
    #   if $thaw;

    my $self;

    my $iter;
    my $is_exhausted;
    my $iterator_state;

    my sub init {
        $iterator_state = IterState_EXHAUSTED;
        if ( @stack ) {
            $iter           = $stack[0];
            $is_exhausted   = $iter->can( 'is_exhausted' );
            $iterator_state = IterState_CLEAR;
        }
    }
    init();

    my %params = (

        ( +_NAME ) => 'istack',

        ( +_SELF ) => \$self,

        ( +RESET ) => sub {
            $prev  = $current = undef;
            @stack = @snapshot;
            init();
        },

        ( +REWIND ) => sub {
            @stack = @snapshot;
            init();
        },

        ( +STATE ) => \$iterator_state,

        ( +NEXT ) => sub {
            return $self->signal_exhaustion if $iterator_state == IterState_EXHAUSTED;

            while ( 1 ) {
                my $value = $iter->();

                if ( defined( $value ) || !$iter->$is_exhausted ) {
                    $prev = $current;
                    return $current = $value;
                }

                last unless defined( $iter = shift @stack );
                $is_exhausted = $iter->can( 'is_exhausted' );
            }

            $prev = $current;
            return $current = $self->signal_exhaustion;
        },

        ( +PREV ) => sub {
            return $prev;
        },

        ( +CURRENT ) => sub {
            return $self->signal_exhaustion if !@stack;
            return $current;
        },

        ( +_ROLES ) => [],

        ( +_DEPENDS ) => \@snapshot,

        ( +METHODS ) => {
            push => sub ( $, @iters ) {
                push @stack, map { to_iterator( $_, { ( +EXHAUSTION ) => RETURN } ) } @iters;
                $self->_clear_state;
                init() if @stack == 1;
            },

            pop => sub ($) {
                if ( @stack == 1 ) {
                    $iterator_state = IterState_EXHAUSTED;
                    $iter           = $is_exhausted = undef;
                }
                return CORE::pop( @stack );
            },

            unshift => sub ( $, @iters ) {
                unshift @stack, map { to_iterator( $_, { ( +EXHAUSTION ) => RETURN } ) } @iters;
                init();
            },

            shift => sub ($) {
                if ( @stack == 1 ) {
                    $iterator_state = IterState_EXHAUSTED;
                    $iter           = $is_exhausted = undef;
                }
                my $ret = CORE::shift( @stack );
                init();
                return $ret;
            },

            snapshot => sub ($) {
                @snapshot = @stack;
            },
        },

    );

    return \%params;
}


__PACKAGE__->_add_roles( qw[
      State::Closure
      Next::ClosedSelf
      Rewind::Closure
      Reset::Closure
      Current::Closure
      Prev::Closure
] );

1;

#
# This file is part of Iterator-Flex
#
# This software is Copyright (c) 2018 by Smithsonian Astrophysical Observatory.
#
# This is free software, licensed under:
#
#   The GNU General Public License, Version 3, June 2007
#

__END__