File Coverage

blib/lib/Hash/Iterator.pm

Criterion	Covered	Total	%
statement	76	88	86.3
branch	18	30	60.0
condition	2	3	66.6
subroutine	16	21	76.1
pod	8	9	88.8
total	120	151	79.4

use utf8;

package Hash::Iterator;

use strict;
use warnings FATAL => 'all';
use Carp ();

use constant MsgEmptyHash => 'the iterator has no values';
use constant TRUE         => 1;
use constant FALSE        => 0;

our $VERSION = '0.002';

sub new {
    my $class = shift;

    Carp::croak("new() requires key-value pairs")
      unless @_ % 2 == 0;

    my ( @keys, %data, $object );

    while (@_) {
        my $k = shift;
        push @keys, $k;
        $data{$k} = shift;
    }

    $object = {
        Keys          => [@keys],
        Data          => {%data},
        LengthKeys    => $#keys,
        CurrentState  => -1,
        PreviousState => -1,
    };

    return bless $object, $class;
}

sub done {
    my $self = shift;

    return ( $self->_get_position == $self->_get_LengthKeys )
      ? TRUE
      : FALSE;
}

sub next {
    my $self = shift;

    unless ( %{ $self->{Data} } ) {
        Carp::croak(MsgEmptyHash);
    }

    if ( $self->{LengthKeys} > $self->{CurrentState} ) {
        $self->{PreviousState} = $self->{CurrentState};
        $self->{CurrentState}++;
    }
    else {
        return 0;
    }
    return 1;
}

sub previous {
    my $self = shift;

    if (    ( int $self->{CurrentState} != -1 )
        and ( int $self->{PreviousState} != -1 ) )
    {
        $self->{CurrentState} = $self->{PreviousState};
        $self->{PreviousState}--;

        return 1;
    }
    return undef;
}

sub peek_key {
    my $self = shift;
    my $key  = $self->_get_key;

    return $key if $key;
    return undef;
}

sub peek_value {
    my $self  = shift;
    my $value = $self->_get_value;

    if ( ref $value eq 'HASH' ) {
        return \%$value;
    }
    elsif ( ref $value eq 'ARRAY' ) {
        return \@$value;
    }
    else {
        return $value;
    }
}

sub is_ref {
    my ( $self, $ref ) = @_;
    my $value = $self->_get_value;

    if ( ref $value eq $ref ) {
        return 1;
    }
    return;
}

sub get_data {
    my $self = shift;
    return wantarray
      ? @{ $self->{Data} }
      : $self->_get_LengthKeys;
}

sub get_keys {
    my $self = shift;
    return wantarray
      ? @{ $self->{Keys} }
      : $self->_get_LengthKeys;
}

sub _get_value {
    my $self = shift;

    my ( $CurrentValue, $CurrentKey );
    eval {
        $CurrentKey   = ${ $self->{Keys} }[ $self->_get_position ];
        $CurrentValue = ${ $self->{Data} }{$CurrentKey};
    };
    Carp::croak($@) if $@;

    return $CurrentValue if $CurrentValue;
    return undef;
}

sub _get_key {
    my $self = shift;

    my $curKey;
    eval { $curKey = ${ $self->{Keys} }[ $self->_get_position ]; };
    Carp::croak($@) if $@;

    return $curKey if $curKey;
}

sub _get_position      { shift->{CurrentState} }
sub _get_PreviousState { shift->{PreviousState} }
sub _get_LengthKeys    { shift->{LengthKeys} }

1;

__END__