File Coverage

blib/lib/Iterator/Flex/ArrayLike.pm

Criterion	Covered	Total	%
statement	58	58	100.0
branch	13	22	59.0
condition	3	15	20.0
subroutine	15	15	100.0
pod	1	2	50.0
total	90	112	80.3

package Iterator::Flex::ArrayLike;

# ABSTRACT: ArrayLike Iterator Class

use v5.28;
use strict;
use warnings;
use experimental 'signatures';

our $VERSION = '0.33';

use Ref::Util;
use Iterator::Flex::Utils ':IterAttrs', 'resolve_meth';
use namespace::clean;

use parent 'Iterator::Flex::Base';



























































sub new ( $class, $obj, $pars = {} ) {

    $class->_croak( parameter => q{argument must be a blessed reference} )
      unless Ref::Util::is_blessed_ref( $obj );

    $class->SUPER::new( { object => $obj }, $pars );
}

sub construct ( $class, $state ) {

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

    my ( $obj, $prev, $current, $next, $length, $at )
      = @{$state}{qw[ object prev current next length at ]};

    throw_failure( parameter => q{state 'object' argument must be a blessed reference} )
      unless Ref::Util::is_blessed_ref( $obj );

    $length = resolve_meth( $obj, $length, 'length', 'len' );

    $at = resolve_meth( $obj, $at, 'at', 'getitem' );

    my $len = $obj->$length;

    $next = 0 unless defined $next;

    throw_failure( parameter => q{illegal value for state 'prev' argument} )
      if defined $prev && ( $prev < 0 || $prev >= $len );

    throw_failure( parameter => q{illegal value for state 'current' argument} )
      if defined $current && ( $current < 0 || $current >= $len );

    throw_failure( parameter => q{illegal value for state 'next' argument} )
      if $next < 0 || $next > $len;

    my $self;

    return {

        ( +_SELF ) => \$self,

        ( +RESET ) => sub {
            $prev = $current = undef;
            $next = 0;
        },

        ( +REWIND ) => sub {
            $next = 0;
        },

        ( +PREV ) => sub {
            return defined $prev ? $obj->$at( $prev ) : undef;
        },

        ( +CURRENT ) => sub {
            return defined $current ? $obj->$at( $current ) : undef;
        },

        ( +NEXT ) => sub {
            if ( $next == $len ) {
                # if first time through, set current
                $prev = $current
                  if !$self->is_exhausted;
                return $current = $self->signal_exhaustion;
            }
            $prev    = $current;
            $current = $next++;

            return $obj->$at( $current );
        },
    };
}


__PACKAGE__->_add_roles( qw[
      State::Registry
      Next::ClosedSelf
      Rewind::Closure
      Reset::Closure
      Prev::Closure
      Current::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__