File Coverage

blib/lib/EO/Array.pm

Criterion	Covered	Total	%
statement	7	9	77.7
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	10	12	83.3

package EO::Array;

use strict;
use warnings;
use EO::Collection;

our $VERSION = 0.96;
our @ISA = qw( EO::Collection );

use overload '@{}' => 'get_reference',
             'fallback' => 1;

sub init {
  my $self = CORE::shift;
  if ($self->SUPER::init( @_ )) {
    $self->element( [] );
    return 1;
  }
  return 0;
}

sub get_reference {
  my $self = shift;
  return $self->element;
}

sub new_with_array {
  my $class = CORE::shift;
  my $array;
  if (@_ > 1) {
    $array = [ @_ ];
  } else {
    $array = CORE::shift;
    if (defined($array) && !ref($array)) {
      print "Not an array, making it one...\n";
      $array = [ $array ];
    }
  }
  if (!$array) {
    throw EO::Error::InvalidParameters text => 'no array specified';
  }
  if (!ref($array)) {
    throw EO::Error::InvalidParameters text => 'not a reference';
  }
  if (ref($array) && ref($array) ne 'ARRAY') {
    throw EO::Error::InvalidParameters text => 'not an array reference';
  }
  my $self = $class->new();
  $self->element( $array );
  return $self;
}

sub do {
  my $self = CORE::shift;
  my $code = CORE::shift;
  my $array = ref($self)->new();
  foreach my $element (@{ $self->element }) {
    local $_ = $element;
    $array->push( $code->( $element ) );
  }
  return $array;
}

sub reverse {
  my $self = CORE::shift;
  ref($self)->new_with_array( CORE::reverse( @{ $self->element } ) );
}

sub select {
  my $self = CORE::shift;
  my $code = CORE::shift;
  my $array = ref($self)->new();
  foreach my $element (@{ $self->element }) {
    local $_ = $element;
    $array->push( $element ) if $code->( $element );
  }
  return $array;
}

sub at {
  my $self = CORE::shift;
  my $idx  = CORE::shift;
  if (!defined($idx)) {
    throw EO::Error::InvalidParameters
      text => 'no index provided for the array';
  }
  if ($idx =~ /\D/) {
    throw EO::Error::InvalidParameters
      text => 'non-integer index specified';
  }
  if (@_) {
    $self->element->[ $idx ] = CORE::shift;
    return $self;
  }
  return $self->element->[ $idx ];
}

sub object_at_index : Deprecated {
  my $self = shift;
  $self->at( @_ );
}

sub delete {
  my $self = CORE::shift;
  my $idx  = CORE::shift;
  if (!defined($idx)) {
    throw EO::Error::InvalidParameters text => "no index provided for the array";
  }
  if ($idx =~ /\D/) {
    throw EO::Error::InvalidParameters text => 'non-integer index specified';
  }
  $self->splice( $idx, 1 );
}

sub splice {
  my $self = CORE::shift;
  my $offset = CORE::shift;
  my $length = CORE::shift;
  if (!@_ && $length) {

    return CORE::splice( @$self, $offset, $length );

  } elsif (!defined $length) {

    return CORE::splice( @$self, $offset );

  } elsif (!defined $offset) {

    return CORE::splice( @$self  );

  } else {

    return CORE::splice(@$self, $offset, $length, @_);

  }
}

sub count {
  my $self = CORE::shift;
  return scalar( $self->iterator );
}

sub push {
  my $self = CORE::shift;
  $self->splice( $self->count, 0, @_ );
  return $self;
}

sub pop {
  my $self = CORE::shift;
  $self->splice( -1 );
}

sub shift {
  my $self = CORE::shift;
  $self->splice( 0, 1 );
}

sub unshift {
  my $self = CORE::shift;
  $self->splice( 0, 0, @_ );
  return $self;
}

sub join {
  my $self = CORE::shift;
  my $joiner = CORE::shift;
  return join($joiner, $self->iterator);
}

sub iterator {
  my $self = CORE::shift;
  my @list = @{ $self->element };
  return @list;
}

1;

__END__