UTF support version

Collection.php

@@ -0,0 +1,259 @@
+<?php
+
+namespace k\util\fuzzy;
+
+/**
+ * Collection provides an array-like interface for working with a set of elements.
+ *
+ * @author Michael Crumm <[email protected]>
+ */
+class Collection implements \ArrayAccess, \IteratorAggregate, \Countable
+{
+    /** @var array */
+    private $elements;
+
+    /**
+     * Collection Constructor.
+     *
+     * @param array $elements
+     */
+    public function __construct(array $elements = [ ])
+    {
+        $this->elements = $elements;
+    }
+
+    /**
+     * Adds an element to this collection.
+     *
+     * @param mixed $element Elements can be of any type.
+     */
+    public function add($element)
+    {
+        $this->elements[] = $element;
+    }
+
+    /**
+     * Returns true if the given elements exists in this collection.
+     *
+     * @param mixed $element
+     * @return boolean
+     */
+    public function contains($element)
+    {
+        return in_array($element, $this->elements, true);
+    }
+
+    /**
+     * @return int
+     */
+    public function count()
+    {
+        return count($this->elements);
+    }
+
+    /**
+     * Returns the set difference of this Collection and another comparable.
+     *
+     * @param array|\Traversable $cmp Value to compare against.
+     * @return static
+     * @throws \InvalidArgumentException When $cmp is not a valid for
+     * difference.
+     */
+    public function difference($cmp)
+    {
+        return new static(array_diff($this->elements, static::coerce($cmp)->toArray()));
+    }
+
+    /**
+     * @param callable $p
+     * @return static
+     */
+    public function filter(\Closure $p)
+    {
+        return new static(array_filter($this->elements, $p));
+    }
+
+    /**
+     * @return \ArrayIterator
+     */
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->elements);
+    }
+
+    /**
+     * Returns the set intersection of this Collection and another comparable.
+     *
+     * @param array|\Traversable $cmp Value to compare against.
+     * @return static
+     * @throws \InvalidArgumentException When $cmp is not a valid for
+     * intersection.
+     */
+    public function intersection($cmp)
+    {
+        return new static(array_intersect($this->elements, static::coerce($cmp)->toArray()));
+    }
+
+    /**
+     * Checks whether or not this collection is empty.
+     *
+     * @return boolean
+     */
+    public function isEmpty()
+    {
+        return empty($this->elements);
+    }
+
+    /**
+     * Returns a string containing all elements of this collection with a
+     * glue string.
+     *
+     * @param string $glue
+     * @return string A string representation of all the array elements in the
+     * same order, with the glue string between each element.
+     */
+    public function join($glue = ' ')
+    {
+        return implode((string) $glue, $this->elements);
+    }
+
+    /**
+     * Returns a new collection, the values of which are the result of mapping
+     * the predicate function onto each element in this collection.
+     *
+     * @param \Closure $p Predicate function.
+     * @return static
+     */
+    public function map(\Closure $p)
+    {
+        return new static(array_map($p, $this->elements));
+    }
+
+    /**
+     * Apply a multisort to this collection of elements.
+     *
+     * @param mixed $arg [optional]
+     * @param mixed $arg [optional]
+     * @param mixed $_ [optional]
+     * @return static
+     */
+    public function multiSort()
+    {
+        if (func_num_args() < 1) { throw new \LogicException('multiSort requires at least one argument.'); }
+
+        $elements = $this->elements;
+        $args     = func_get_args();
+        $args[]   = &$elements;
+
+        call_user_func_array('array_multisort', $args);
+
+        return new static($elements);
+    }
+
+    /**
+     * @param mixed $offset
+     * @return bool
+     */
+    public function offsetExists($offset)
+    {
+        return isset ($this->elements[$offset]);
+    }
+
+    /**
+     * @param mixed $offset
+     * @return mixed
+     */
+    public function offsetGet($offset)
+    {
+        return isset ($this->elements[$offset]) ? $this->elements[$offset] : null;
+    }
+
+    /**
+     * @param mixed $offset
+     * @param mixed $value
+     */
+    public function offsetSet($offset, $value)
+    {
+        if (!is_null($offset)) {
+            $this->elements[$offset] = $value;
+            return;
+        }
+
+        $this->elements[] = $value;
+    }
+
+    /**
+     * @param mixed $offset
+     */
+    public function offsetUnset($offset)
+    {
+        unset($this->elements[$offset]);
+    }
+
+    /**
+     * Returns a new collection with the elements of this collection, reversed.
+     *
+     * @return static
+     */
+    public function reverse()
+    {
+        return new static(array_reverse($this->elements));
+    }
+
+    /**
+     * @param $offset
+     * @param null $length
+     * @return static
+     */
+    public function slice($offset, $length = null)
+    {
+        return new static(array_slice($this->elements, $offset, $length, true));
+    }
+
+    /**
+     * Returns a new collection with the elements of this collection, sorted.
+     *
+     * @return static
+     */
+    public function sort()
+    {
+        $sorted = $this->elements;
+
+        sort($sorted);
+
+        return new static($sorted);
+    }
+
+    /**
+     * Returns the elements in this collection as an array.
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->elements;
+    }
+
+    /**
+     * Coerce an array-like value into a Collection.
+     *
+     * @param array|\Traversable $elements    Value to compare against.
+     * @return Collection
+     * @throws \InvalidArgumentException When $cmp is not an array or Traversable.
+     */
+    public static function coerce($elements)
+    {
+        if ($elements instanceof Collection) {
+            return $elements;
+        } elseif ($elements instanceof \Traversable) {
+            $elements = iterator_to_array($elements);
+        } elseif (!is_array($elements)) {
+            throw new \InvalidArgumentException(sprintf(
+                'coerce requires an array or \Traversable, %s given.',
+                is_object($elements) ? get_class($elements) : gettype($elements)
+            ));
+        }
+
+        return new static($elements);
+    }
+}