Collection::rewind()   A
last analyzed

Complexity

Conditions 1
Paths 1

Size

Total Lines 3
Code Lines 1

Duplication

Lines 0
Ratio 0 %

Importance

Changes 1
Bugs 0 Features 0
Metric Value
cc 1
eloc 1
c 1
b 0
f 0
nc 1
nop 0
dl 0
loc 3
rs 10
1
<?php
2
3
namespace Tleckie\Collection;
4
5
use Closure;
6
use function array_push;
7
use function array_reverse;
8
use function array_shift;
9
use function array_unshift;
10
use function current;
11
use function key;
12
use function next;
13
use function reset;
14
use function shuffle;
15
use function usort;
16
17
/**
18
 * Class Collection
19
 *
20
 * @package Tleckie\Collection
21
 * @author  Teodoro Leckie Westberg <[email protected]>
22
 */
23
class Collection implements CollectionInterface
24
{
25
    /**
26
     * @var array
27
     */
28
    protected array $items;
29
30
    /**
31
     * Collection constructor.
32
     *
33
     * @param array|CollectionInterface $items
34
     */
35
    public function __construct(array|CollectionInterface $items = [])
36
    {
37
        $this->items = ($items instanceof CollectionInterface) ? $items->toArray() : $items;
38
    }
39
40
    /**
41
     * @param callable|Closure $callable
42
     * @return CollectionInterface
43
     */
44
    public function filter(callable|Closure $callable): CollectionInterface
45
    {
46
        return $this->internalFilter($callable);
47
    }
48
49
    /**
50
     * @param callable|Closure $callable
51
     * @param bool             $keep
52
     * @return CollectionInterface
53
     */
54
    private function internalFilter(callable|Closure $callable, bool $keep = true): CollectionInterface
55
    {
56
        $items = [];
57
        $copy = $this->items;
58
59
        foreach ($copy as $key => $value) {
60
            if ($keep === $callable($key, $value)) {
61
                $items[$key] = $value;
62
            }
63
        }
64
65
        return new Collection($items);
66
    }
67
68
    /**
69
     * @param callable|Closure $callable
70
     * @return CollectionInterface
71
     */
72
    public function filterNot(callable|Closure $callable): CollectionInterface
73
    {
74
        return $this->internalFilter($callable, false);
75
    }
76
77
    /**
78
     * @param callable|Closure $callable
79
     * @return CollectionInterface
80
     */
81
    public function find(callable|Closure $callable): CollectionInterface
82
    {
83
        $items = [];
84
        $copy = $this->items;
85
86
        foreach ($copy as $key => $value) {
87
            if ($callable($key, $value) === true) {
88
                $items[$key] = $value;
89
            }
90
        }
91
92
        return new Collection($items);
93
    }
94
95
    /**
96
     * @param string|int $index
97
     * @return mixed
98
     */
99
    public function findIndex(string|int $index): mixed
100
    {
101
        foreach ($this->items as $key => $value) {
102
            if ($key === $index) {
103
                return $value;
104
            }
105
        }
106
107
        return false;
108
    }
109
110
    /**
111
     * @param callable|Closure $callable
112
     * @return CollectionInterface
113
     */
114
    public function sort(callable|Closure $callable): CollectionInterface
115
    {
116
        $items = $this->items;
117
118
        usort($items, $callable);
119
120
        return new Collection($items);
121
    }
122
123
    /**
124
     * @return CollectionInterface
125
     */
126
    public function shuffle(): CollectionInterface
127
    {
128
        $items = $this->items;
129
        shuffle($items);
130
131
        return new Collection($items);
132
    }
133
134
    /**
135
     * @return CollectionInterface
136
     */
137
    public function reverse(): CollectionInterface
138
    {
139
        return new Collection(
140
            array_reverse($this->items, true)
141
        );
142
    }
143
144
    /**
145
     * @param mixed $item
146
     * @return CollectionInterface
147
     */
148
    public function prepend(mixed $item): CollectionInterface
149
    {
150
        array_unshift($this->items, $item);
151
152
        return $this;
153
    }
154
155
    /**
156
     * @return array
157
     */
158
    public function toArray(): array
159
    {
160
        return $this->items;
161
    }
162
163
    /**
164
     * @return mixed
165
     */
166
    public function current(): mixed
167
    {
168
        return current($this->items);
169
    }
170
171
    public function next(): void
172
    {
173
        next($this->items);
174
    }
175
176
    /**
177
     * @return bool
178
     */
179
    public function valid(): bool
180
    {
181
        return $this->key() !== null;
182
    }
183
184
    /**
185
     * @return string|float|int|bool|null
186
     */
187
    public function key(): string|float|int|bool|null
188
    {
189
        return key($this->items);
190
    }
191
192
    /**
193
     * @return int
194
     */
195
    public function count(): int
196
    {
197
        return count($this->items);
198
    }
199
200
    /**
201
     * @return mixed
202
     */
203
    public function rewind(): mixed
204
    {
205
        return reset($this->items);
206
    }
207
208
    /**
209
     * @param mixed $item
210
     * @return CollectionInterface
211
     */
212
    public function push(mixed $item): CollectionInterface
213
    {
214
        return $this->append($item);
215
    }
216
217
    /**
218
     * @param mixed $item
219
     * @return CollectionInterface
220
     */
221
    public function append(mixed $item): CollectionInterface
222
    {
223
        array_push($this->items, $item);
224
225
        return $this;
226
    }
227
228
    /**
229
     * @return mixed
230
     */
231
    public function pull(): mixed
232
    {
233
        return array_shift($this->items);
234
    }
235
}
236