File Coverage

blib/lib/Iterator/Flex/Common.pm

Criterion	Covered	Total	%
statement	132	145	91.0
branch	6	8	75.0
condition			n/a
subroutine	26	29	89.6
pod	19	20	95.0
total	183	202	90.5

package Iterator::Flex::Common;

# ABSTRACT: Iterator Generators and Adapters

use v5.28;
use strict;
use warnings;

use experimental qw( postderef signatures );

our $VERSION = '0.33';

use Exporter 'import';

our @EXPORT_OK = qw[
  iterator iter iarray ibatch ibuffer icycle icache
  icat ichain ichunk iflatten igather igrep imap
  ipermute
  iproduct iseq istack itake ifreeze izip
  thaw
];

our %EXPORT_TAGS = ( all => \@EXPORT_OK );

use Ref::Util             qw[ is_arrayref is_hashref is_ref is_globref ];
use Module::Runtime       qw[ require_module ];
use Iterator::Flex::Utils qw[ throw_failure ];
use Iterator::Flex::Factory 'to_iterator', 'construct_from_iterable';




























sub iterator : prototype(&@) ( $code, $pars = {} ) {
    Iterator::Flex::Factory::construct_from_iterable( $code, $pars );
}

















sub iter ( $iterable, $pars = {} ) {
    to_iterator( $iterable, $pars );
}




























sub iarray ( $array, $pars = {} ) {
    require Iterator::Flex::Array;
    return Iterator::Flex::Array->new( $array, $pars );
}




























sub icache ( $iterable, $pars = {} ) {
    require Iterator::Flex::Cache;
    Iterator::Flex::Cache->new( $iterable, $pars );
}








































sub icat ( @args ) {
    require Iterator::Flex::Cat;
    Iterator::Flex::Cat->new( @args );
}

sub ichain;
*ichain = \&icat;





























sub ichunk ( $iterable, $pars = {} ) {
    require Iterator::Flex::Chunk;
    Iterator::Flex::Chunk->new( $iterable, $pars );
}

sub ibatch;
*ibatch = \&ichunk;


























sub icycle ( $array, $pars = {} ) {
    require Iterator::Flex::Cycle;
    return Iterator::Flex::Cycle->new( $array, $pars );
}


















sub ibuffer ( $iterable, $n = 0, $pars = {} ) {
    require Iterator::Flex::Buffer;
    return Iterator::Flex::Buffer->new( $iterable, $n, $pars );
}






















sub iflatten ( $iterable, $pars = {} ) {
    require Iterator::Flex::Flatten;
    return Iterator::Flex::Flatten->new( $iterable, $pars );
}


























sub igather : prototype(&$@) ( $code, $iterable, $pars = {} ) {
    require Iterator::Flex::Gather;
    Iterator::Flex::Gather->new( $code, $iterable, $pars );
}























sub igrep : prototype(&$@) ( $code, $iterable, $pars = {} ) {
    require Iterator::Flex::Grep;
    Iterator::Flex::Grep->new( $code, $iterable, $pars );
}
























sub imap : prototype(&$@) ( $code, $iterable, $pars = {} ) {
    require Iterator::Flex::Map;
    Iterator::Flex::Map->new( $code, $iterable, $pars );
}




























sub ipermute {
    require Iterator::Flex::Permute;
    return Iterator::Flex::Permute->new( @_ );
}





































sub iproduct {
    require Iterator::Flex::Product;
    return Iterator::Flex::Product->new( @_ );
}
































sub iseq {
    require Iterator::Flex::Sequence;
    Iterator::Flex::Sequence->new( @_ );
}






























sub istack ( @args ) {
    require Iterator::Flex::Stack;
    Iterator::Flex::Stack->new( @args );
}
































sub itake ( @args ) {
    require Iterator::Flex::Take;
    Iterator::Flex::Take->new( @args );
}

































sub ifreeze : prototype(&$@) ( $code, $iterable, $pars = {} ) {
    require Iterator::Flex::Freeze;
    Iterator::Flex::Freeze->new( $code, $iterable, $pars );
}




























sub izip ( @args ) {
    require Iterator::Flex::Zip;
    Iterator::Flex::Zip->new( @args );
}












sub thaw ( $frozen, $pars = {} ) {

    my @steps = $frozen->@*;

    # parent data and iterator state is last
    my $exhausted = pop @steps;
    my $parent    = pop @steps;

    my @depends = map { thaw( $_ ) } @steps;

    my ( $package, $state ) = @$parent;

    throw_failure( parameter => "state argument for $package constructor must be a HASH  reference" )
      unless is_hashref( $state );

    require_module( $package );
    my $new_from_state = $package->can( 'new_from_state' )
      or
      throw_failure( parameter => "unable to thaw: $package doesn't provide 'new_from_state' method" );

    $state->{depends} = \@depends
      if @depends;

    $state->{thaw} = 1;

    my $iter = $package->$new_from_state( $state, $pars );
    $exhausted ? $iter->set_exhausted : $iter->_clear_state;
    return $iter;
}

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__