File Coverage

blib/lib/List/MRU.pm

Criterion	Covered	Total	%
statement	73	73	100.0
branch	32	38	84.2
condition	25	32	78.1
subroutine	15	15	100.0
pod	0	8	0.0
total	145	166	87.3

package List::MRU;

use 5.006;
use strict;
use warnings;
use Carp;

our $VERSION = '0.04';

# -------------------------------------------------------------------------
# Constructor
sub new
{
  my $class = shift;
  my %arg = @_;
  croak "required argument 'max' missing'" unless defined $arg{max};
  croak "'max' argument not an integer'" unless $arg{max} =~ m/^\d+$/;
  croak "'eq' argument not an subroutine'"
    if $arg{eq} && ref $arg{eq} ne 'CODE';
  bless {
    max  => $arg{max},
    'eq' => $arg{eq},
    uuid => $arg{uuid},
    list => [],
    ulist => [],
    current => 0,
  }, $class;
}

# -------------------------------------------------------------------------
# Private methods

sub _truncate
{
  my $self = shift;
  pop @{$self->{list}} while scalar @{$self->{list}} > $self->max;
  if ($self->uuid) {
    pop @{$self->{ulist}} while scalar @{$self->{ulist}} > $self->max;
  }
}

sub _reset { shift->{current} = 0; }

# -------------------------------------------------------------------------
# Public methods

# Add $item, moving to head of list if already exists
#   (returns $self for method chaining)
sub add
{
  my $self = shift;
  my ($item, $uuid) = @_;
  croak "no item given to add" unless defined $item;
  croak "no uuid given to add" if $self->uuid && ! defined $uuid;
  if ($self->delete(item => $item, uuid => $uuid)) {
    unshift @{$self->{list}}, $item;
    unshift @{$self->{ulist}}, $uuid if $self->uuid;
  }
  else {
    unshift @{$self->{list}}, $item;
    unshift @{$self->{ulist}}, $uuid if $self->uuid;
    $self->_truncate;
  }
  $self
}

# Delete (first) matching $item (by self or by uuid), returning it if found.
sub delete
{
  my $self = shift;
  my ($item, $uuid) = @_;
  # Check for named arguments style call
  if ($item && ($item eq 'item' || $item eq 'uuid')) {
    my %arg = @_;
    $arg{$item} = $uuid;
    $item = $arg{item};
    $uuid = $arg{uuid};
  }
  croak "no item given to delete" unless defined $item or defined $uuid;
  my $eq = $self->{eq} || sub { $_[0] eq $_[1] };
  for my $i (0 .. $#{$self->{list}}) {
    if (($self->uuid && $uuid && $self->{ulist}->[$i] eq $uuid) ||
        ($item && $eq->($item, $self->{list}->[$i]))) {
      my $deleted = splice @{$self->{list}}, $i, 1;
      my $udeleted = splice @{$self->{ulist}}, $i, 1 if $self->uuid;
      return wantarray && $self->uuid ? ($deleted, $udeleted) : $deleted;
    }
  }
}

# Iterator
sub each  {
  my $self = shift;
  if ($self->{current} <= $#{$self->{list}}) {
    my $current = $self->{current}++;
    return wantarray ?
      ($self->{list}->[$current], $self->uuid ? $self->{ulist}->[$current] : undef) :
      $self->{list}->[$current];
  }
  else {
    # Reset current
    $self->_reset;
    return wantarray ? () : undef;
  }
}

# Accessors
sub list  { wantarray ? @{shift->{list}} : shift->{list} }
sub max   { shift->{max} }
sub count { scalar @{shift->{list}} }
sub uuid  { shift->{uuid} }

1;

__END__