view release on metacpan or  search on metacpan

lib/Acme/Array/MaxSize.pm  view on Meta::CPAN

package Acme::Array::MaxSize;

use 5.006;
use strict;
use warnings;

use parent 'Tie::Array';
use Carp;

my %max_size;
my $last_index = sub { $max_size{+shift} - 1 };


sub TIEARRAY {
    my ($class, $max_size) = @_;
    my $self = bless [], $class;
    $max_size{$self} = $max_size;
    return $self
}

sub STORE {
    my ($self, $index, $value) = @_;
    if ($index > $self->$last_index) {
        carp 'Array too long';
        return
    }
    $self->[$index] = $value;
}

sub FETCH {
    my ($self, $index) = @_;
    $self->[$index]
}

sub FETCHSIZE {
    my $self = shift;
    @$self
}

sub STORESIZE {
    my ($self, $count) = @_;
    if ($count > $max_size{$self}) {
        carp 'Array too long';
        $count = $max_size{$self};
    }
    $#{$self} = $count - 1;
}

sub SPLICE {
    my ($self, $offset, $length, @list) = @_;
    if ($offset > $max_size{$self}) {
        carp 'Array too long';
        return;
    }

    if ($offset + $length > $max_size{$self}) {
        carp 'Array too long';
        $length = $max_size{$self} - $offset;
    }

    my $asked = @$self - $length + @list;
    if ($asked > $max_size{$self}) {
        carp 'Array too long';
        if ($offset == 0) {
            splice @list, 0, $asked - $max_size{$self};
        } else {
            splice @list, $max_size{$self} - $asked;
        }
    }
    $self->SUPER::SPLICE($offset, $length, @list);
}


=head1 NAME

Acme::Array::MaxSize - Limit the maximal size your arrays can get.

=head1 VERSION

Version 0.04

=cut

our $VERSION = '0.04';


=head1 SYNOPSIS

Your array will never grow bigger over a given limit.

  use Acme::Array::MaxSize;

  tie my @short, 'Acme::Array::MaxSize', 3;
  @short = (1 .. 10);
  print "@short";  # 1 2 3

=head1 DETAILS

When adding new elements, if the maximal size is reached, all other
elements are thrown away.

  tie my @short, 'Acme::Array::MaxSize', 3;
  @short = ('a');
  push @short, 'b' .. 'h';
  print "@short";  # a b c

Inserting elements at the B<very beginning> behaves differently,
though. Each C<unshift> or C<splice> would insert the maximal possible
number of elements B<at the end> of the inserted list: