used arrays for CypherList

Author: transistive

src/Types/CypherList.php

@@ -13,10 +13,20 @@
 
 namespace Laudis\Neo4j\Types;
 
+use function array_filter;
+use function array_key_last;
+use function array_map;
+use function array_reduce;
+use function array_search;
+use function array_slice;
+use ArrayIterator;
 use BadMethodCallException;
-use Ds\Vector;
+use function array_sum;
+use function count;
+use function in_array;
 use Laudis\Neo4j\Contracts\CypherContainerInterface;
-use Traversable;
+use function sort;
+use function usort;
 
 /**
  * @template T
@@ -25,52 +35,60 @@
  */
 final class CypherList implements CypherContainerInterface
 {
-    /** @var Vector<T> */
-    private Vector $vector;
+    /** @var list<T> */
+    private array $array;
 
     /**
-     * @param Vector<T> $vector
+     * @param iterable<T> $array
      */
-    public function __construct(Vector $vector)
+    public function __construct(iterable $array)
     {
-        $this->vector = new Vector($vector);
+        if ($array instanceof self) {
+            $this->array = $array->array;
+        } else {
+            $this->array = [];
+            foreach ($array as $value) {
+                $this->array[] = $value;
+            }
+        }
     }
 
     public function count(): int
     {
-        return $this->vector->count();
+        return count($this->array);
     }
 
     /**
      * @return CypherList<T>
      */
     public function copy(): CypherList
     {
-        return new CypherList($this->vector->copy());
+        $tbr = $this->array;
+
+        return new CypherList($tbr);
     }
 
     public function isEmpty(): bool
     {
-        return $this->vector->isEmpty();
+        return count($this->array) === 0;
     }
 
     /**
      * @return list<T>
      */
     public function toArray(): array
     {
-        return $this->vector->toArray();
+        return $this->array;
     }
 
     public function getIterator()
     {
-        /** @var Traversable<int, T> */
-        return $this->vector->getIterator();
+        return new ArrayIterator($this->array);
     }
 
     public function offsetExists($offset): bool
     {
-        return $this->vector->offsetExists($offset);
+        return isset($this->array[$offset]);
     }
 
     /**
@@ -82,8 +100,7 @@ public function offsetExists($offset): bool
      */
     public function offsetGet($offset)
     {
-        /** @psalm-suppress InvalidReturnStatement */
-        return $this->vector->offsetGet($offset);
+        return $this->array[$offset];
     }
 
     /**
@@ -105,20 +122,36 @@ public function offsetUnset($offset)
 
     /**
      * @param T ...$values
+     *
+     * @deprecated Use hasValue instead
      */
     public function contains(...$values): bool
     {
-        return $this->vector->contains(...$values);
+        foreach ($values as $value) {
+            if (!in_array($value, $this->array, true)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param T $value
+     */
+    public function hasValue($value): bool
+    {
+        return in_array($value, $this->array, true);
     }
 
     /**
-     * @param (callable(T):bool)|null $callback
+     * @param (callable(T):bool) $callback
      *
      * @return CypherList<T>
      */
-    public function filter(callable $callback = null): CypherList
+    public function filter(callable $callback): CypherList
     {
-        return new CypherList($this->vector->filter($callback));
+        return new CypherList(array_filter($this->array, $callback));
     }
 
     /**
@@ -128,40 +161,42 @@ public function filter(callable $callback = null): CypherList
      */
     public function find($value)
     {
-        return $this->vector->find($value);
+        return array_search($value, $this->array, true);
     }
 
     /**
-     * @return T
+     * @return T|null
      */
     public function first()
     {
-        return $this->vector->first();
+        return $this->array[0] ?? null;
     }
 
     /**
      * @return T
      */
     public function get(int $index)
     {
-        return $this->vector->get($index);
+        return $this->array[$index];
     }
 
     public function join(?string $glue = null): string
     {
-        if ($glue === null) {
-            return $this->vector->join();
-        }
-
-        return $this->vector->join($glue);
+        /** @psalm-suppress MixedArgumentTypeCoercion */
+        return implode($glue ?? '', $this->array);
     }
 
     /**
      * @return T
      */
     public function last()
     {
-        return $this->vector->last();
+        $key = array_key_last($this->array);
+        if ($key === null) {
+            return null;
+        }
+
+        return $this->array[$key];
     }
 
     /**
@@ -173,7 +208,7 @@ public function last()
      */
     public function map(callable $callback): CypherList
     {
-        return new CypherList($this->vector->map($callback));
+        return new CypherList(array_map($callback, $this->array));
     }
 
     /**
@@ -183,31 +218,39 @@ public function map(callable $callback): CypherList
      */
     public function merge($values): CypherList
     {
-        return new CypherList($this->vector->merge($values));
+        $tbr = $this->array;
+        foreach ($values as $value) {
+            $tbr[] = $value;
+        }
+
+        return new CypherList($tbr);
     }
 
     /**
-     * @param callable(T, T|null):T $callback
-     * @param T|null                $initial
+     * @template U
      *
-     * @return T|null
+     * @param callable(U|null, T):U $callback
+     * @param U|null                $initial
+     *
+     * @return U|null
      */
     public function reduce(callable $callback, $initial = null)
     {
-        return $this->vector->reduce($callback, $initial);
+        /** @var U|null */
+        return array_reduce($this->array, $callback, $initial);
     }
 
     /**
      * @return CypherList<T>
      */
     public function reversed(): CypherList
     {
-        return new CypherList($this->vector->reversed());
+        return new CypherList(array_reverse($this->array));
     }
 
     public function slice(int $index, int $length = null): CypherList
     {
-        return new CypherList($this->vector->slice($index, $length));
+        return new CypherList(array_slice($this->array, $index, $length));
     }
 
     /**
@@ -217,15 +260,22 @@ public function slice(int $index, int $length = null): CypherList
      */
     public function sorted(callable $comparator = null): CypherList
     {
-        return new CypherList($this->vector->sorted($comparator));
+        $tbr = $this->array;
+        if ($comparator === null) {
+            sort($tbr);
+        } else {
+            usort($tbr, $comparator);
+        }
+
+        return new CypherList($tbr);
     }
 
     /**
      * @return float|int
      */
     public function sum()
     {
-        return $this->vector->sum();
+        return array_sum($this->array);
     }
 
     /**
@@ -234,14 +284,14 @@ public function sum()
     public function jsonSerialize(): array
     {
         /** @var array<int, T> */
-        return $this->vector->jsonSerialize();
+        return $this->array;
     }
 
     /**
      * @return list<T>
      */
     public function __debugInfo()
     {
-        return $this->vector->toArray();
+        return $this->array;
     }
 }