File Coverage

blib/lib/List/DoubleLinked.pm

Criterion	Covered	Total	%
statement	95	105	90.4
branch	20	40	50.0
condition	4	12	33.3
subroutine	20	22	90.9
pod	15	15	100.0
total	154	194	79.3

#
# This file is part of List-DoubleLinked
#
# This software is copyright (c) 2011 by Leon Timmermans.
#
# This is free software; you can redistribute it and/or modify it under
# the same terms as the Perl 5 programming language system itself.
#
package List::DoubleLinked;
BEGIN {
  $List::DoubleLinked::VERSION = '0.003';
}

use strict;
use warnings FATAL => 'all';

use Carp qw/carp/;
use Scalar::Util 'weaken';
use namespace::clean 0.20;
#no autovivication;

sub new {
	my ($class, @items) = @_;
	my $self = bless {
		head => undef,
		tail => undef,
		size => 0,
	}, $class;
	$self->push(@items);
	return $self;
}

## no critic (Subroutines::ProhibitBuiltinHomonyms, ControlStructures::ProhibitCStyleForLoops)

sub push {
	my ($self, @items) = @_;
	for my $item (@items) {
		my $new_tail = {
			item => $item,
			prev => $self->{tail},
			next => undef,
		};
		$self->{tail}{next} = $new_tail if defined $self->{tail};
		$self->{tail}       = $new_tail;
		$self->{head}       = $new_tail if not defined $self->{head};
		$self->{size}++;
	}
	return;
}

sub pop {
	my $self = shift;
	my $ret  = $self->{tail};
	return if not defined $ret;
	$self->{tail} = $ret->{prev};
	$self->{tail}{next} = undef if defined $self->{tail};
	$self->{size}--;
	return $ret->{item};
}

sub unshift {
	my ($self, @items) = @_;
	for my $item (reverse @items) {
		my $new_head = {
			item => $item,
			prev => undef,
			next => $self->{head},
		};
		$self->{head}{prev} = $new_head if defined $self->{head};
		$self->{head}       = $new_head;
		$self->{tail}       = $new_head if not defined $self->{tail};
		$self->{size}++;
	}
	return;
}

sub shift {
	my $self = CORE::shift;
	my $ret  = $self->{head};
	return if not defined $ret;
	$self->{head} = $ret->{next};
	$self->{head}{prev} = undef if defined $self->{tail};
	$self->{size}--;
	return $ret->{item};
}

sub flatten {
	my $self = CORE::shift;
	my @ret;
	for (my $current = $self->{head} ; defined $current ; $current = $current->{next}) {
		CORE::push @ret, $current->{item};
	}
	return @ret;
}

sub front {
	my $self = CORE::shift;
	return defined $self->{head} ? $self->{head}{item} : undef;
}

sub back {
	my $self = CORE::shift;
	return defined $self->{tail} ? $self->{tail}{item} : undef;
}

sub empty {
	my $self = CORE::shift;
	return not $self->{size};
}

sub size {
	my $self = CORE::shift;
	return $self->{size};
}

sub insert_before {
	my ($self, $iter, @items) = @_;
	my $node = $iter->[0];
	for my $item (@items) {
		my $new_node = {
			item => $item,
			prev => $node->{prev},
			next => $node,
		};
		$node->{prev}{next} = $new_node if defined $node->{prev};
		$node->{prev} = $new_node;

		$self->{head} = $node->{next} if defined $self->{head} and $self->{head} == $node;
		$self->{size}++;
	}
	return;
}

sub insert_after {
	my ($self, $iter, @items) = @_;
	my $node = $iter->[0];
	for my $item (@items) {
		my $new_node = {
			item => $item,
			prev => $node,
			next => $node->{next},
		};
		$node->{next}{prev} = $new_node if defined $node->{next};
		$node->{next} = $new_node;

		$self->{tail} = $new_node if defined $self->{tail} and $self->{tail} == $node;
		$node = $new_node;
		$self->{size}++;
	}
	return;
}

sub erase {
	my ($self, $node) = @_;

	$node->{prev}{next} = $node->{next} if defined $node->{prev};
	$node->{next}{prev} = $node->{prev} if defined $node->{next};

	$self->{head} = $node->{next}     if defined $self->{head} and $self->{head} == $node;
	$self->{tail} = $node->{previous} if defined $self->{tail} and $self->{tail} == $node;

	$self->{size}--;
	weaken $node;
	carp 'Node may be leaking' if $node;

	return;
}

sub begin {
	my $self = CORE::shift;
	require List::DoubleLinked::Iterator;

	return List::DoubleLinked::Iterator->new($self, $self->{head});
}

sub end {
	my $self = CORE::shift;
	require List::DoubleLinked::Iterator;

	return List::DoubleLinked::Iterator->new($self->{tail});
}

sub DESTROY {
	my $self    = CORE::shift;
	my $current = $self->{head};
	while ($current) {
		delete $current->{prev};
		$current = delete $current->{next};
		$self->{size}--;
	}
	warn "Size of Linked List is $self->{size}, should be 0 after DESTROY" if $self->{size} != 0;
	return;
}

# ABSTRACT: Double Linked Lists for Perl

1;


__END__