File Coverage

File:lib/List/Enumerator/Array.pm
Coverage:87.1%

linestmtbrancondsubpodtimecode
1package List::Enumerator::Array;
2
5
5
5
22
16
38
use base qw/List::Enumerator::Role/;
3use overload
4
5
122
        '<<' => \&push,
5        '+' => \&add,
6        '@{}' => \&to_a,
7
5
5
36
8
        fallback => 1;
8
9
5
5
5
27
8
25
no warnings 'once';
10
11__PACKAGE__->mk_accessors(qw/array index/);
12
13sub BUILD {
14
190
0
310
        my ($self) = @_;
15
190
588
        $self->array([]) unless $self->array;
16
190
2071
        $self->index(0);
17}
18
19sub _next {
20
254
335
        my ($self) = @_;
21
22
254
678
        my $i = $self->index;
23
24
254
254
1828
673
        if ($i < @{$self->array}) {
25
205
1940
                $self->index($i + 1);
26
205
2039
                $self->array->[$i];
27        } else {
28
49
511
                $self->stop;
29        }
30}
31
32sub _rewind {
33
16
23
        my ($self) = @_;
34
35
16
49
        $self->index(0);
36
16
192
        $self;
37}
38
39sub to_a {
40
80
0
152
        my ($self) = @_;
41
80
375
        $self->array;
42}
43*as_list = \&to_a;
44
45sub to_list {
46
89
0
142
        my ($self) = @_;
47
89
89
108
253
        @{$self->array};
48}
49
50sub push {
51
2
0
10
        my ($self, @args) = @_;
52
2
2
3
6
        CORE::push @{$self->array}, @args;
53
2
22
        $self;
54}
55
56sub add {
57
2
0
6
        my ($self, $array, $bool) = @_;
58
1
1
4
4
        $bool ? [ @$array, @{$self->array} ]
59
2
6
              : [ @{$self->array}, @$array ];
60}
61
62sub unshift {
63
2
0
11
        my ($self, @args) = @_;
64
2
2
3
7
        CORE::unshift @{$self->array}, @args;
65
2
23
        $self;
66}
67
68sub prepend {
69
2
0
11
        my ($self, $args) = @_;
70
2
2
3
7
        CORE::unshift @{$self->array}, @$args;
71
2
20
        $self;
72}
73
74sub concat {
75
4
0
20
        my ($self, $args) = @_;
76
4
4
5
12
        CORE::push @{$self->array}, @$args;
77
4
39
        $self;
78}
79*append = \&concat;
80
81sub shift {
82
1
0
3
        my ($self) = @_;
83
1
1
2
5
        CORE::shift @{$self->array};
84}
85
86sub pop {
87
1
0
3
        my ($self) = @_;
88
1
1
2
4
        CORE::pop @{$self->array};
89}
90
91sub delete {
92
2
0
10
        my ($self, $target, $block) = @_;
93
2
4
        my $ret = [];
94
2
2
4
7
        for (0 .. $#{$self->array}) {
95
8
8
104
22
                my $item = CORE::shift @{$self->array};
96
8
67
                if ($item eq $target) {
97
2
6
                        CORE::push @$ret, $self->array->[$_];
98                } else {
99
6
6
6
15
                        CORE::push @{$self->array}, $item;
100                }
101        }
102
2
50
        @$ret ? $target
103              : ref($block) eq "CODE" ? $block->(local $_ = $target)
104                                      : undef;
105}
106
107sub delete_if {
108
1
0
8
        my ($self, $block) = @_;
109
1
4
        my $ret = [];
110
1
1
2
3
        for my $index (0 .. $#{$self->array}) {
111
5
5
28
14
                my $item = CORE::shift @{$self->array};
112
5
43
                if ($block->(local $_ = $item)) {
113
2
14
                        CORE::push @$ret, $item;
114                } else {
115
3
3
16
9
                        CORE::push @{$self->array}, $item;
116                }
117        }
118
1
14
        wantarray? @$ret : List::Enumerator::Array->new(array => $ret);
119}
120
121sub delete_at {
122
3
0
12
        my ($self, $index) = @_;
123
3
3
4
10
        return if $index > $#{$self->array};
124
2
21
        my $ret;
125
2
2
3
6
        for (0 .. $#{$self->array}) {
126
9
9
58
22
                my $item = CORE::shift @{$self->array};
127
9
113
                if ($_ == $index) {
128
2
5
                        $ret = $item;
129                } else {
130
7
7
6
19
                        CORE::push @{$self->array}, $item;
131                }
132        }
133
2
24
        $ret;
134}
135
136# for performance
137sub each {
138
13
0
56
        my ($self, $block) = @_;
139
13
45
        $self->rewind;
140
141
142
13
32
        if ($block) {
143
13
21
                eval {
144
13
13
244
41
                        for (@{ $self->array }) {
145
32
239
                                $block->(local $_ = $_);
146                        }
147
13
99
                }; if (Exception::Class->caught("StopIteration") ) { } else {
148
6
123
                        my $e = Exception::Class->caught();
149
6
52
                        ref $e ? $e->rethrow : die $e if $e;
150                }
151        }
152
153
13
40
        $self;
154}
155
156sub map {
157
5
0
25
        my ($self, $block) = @_;
158
5
16
        $self->rewind;
159
5
8
        my @ret;
160
161
5
15
5
7
111
14
        @ret = CORE::map({ $block->(local $_ = $_) } @{ $self->array });
162
163
5
63
        wantarray? @ret : List::Enumerator::Array->new(array => \@ret);
164}
165
166
1671;