| <?php |
| |
| namespace Tightenco\Collect\Support; |
| |
| use Countable; |
| use Tightenco\Collect\Contracts\Support\Arrayable; |
| use Tightenco\Collect\Contracts\Support\Jsonable; |
| use IteratorAggregate; |
| use JsonSerializable; |
| |
| interface Enumerable extends Arrayable, Countable, IteratorAggregate, Jsonable, JsonSerializable |
| { |
| /** |
| * Create a new collection instance if the value isn't one already. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public static function make($items = []); |
| |
| /** |
| * Create a new instance by invoking the callback a given amount of times. |
| * |
| * @param int $number |
| * @param callable|null $callback |
| * @return static |
| */ |
| public static function times($number, callable $callback = null); |
| |
| /** |
| * Create a collection with the given range. |
| * |
| * @param int $from |
| * @param int $to |
| * @return static |
| */ |
| public static function range($from, $to); |
| |
| /** |
| * Wrap the given value in a collection if applicable. |
| * |
| * @param mixed $value |
| * @return static |
| */ |
| public static function wrap($value); |
| |
| /** |
| * Get the underlying items from the given collection if applicable. |
| * |
| * @param array|static $value |
| * @return array |
| */ |
| public static function unwrap($value); |
| |
| /** |
| * Create a new instance with no items. |
| * |
| * @return static |
| */ |
| public static function empty(); |
| |
| /** |
| * Get all items in the enumerable. |
| * |
| * @return array |
| */ |
| public function all(); |
| |
| /** |
| * Alias for the "avg" method. |
| * |
| * @param callable|string|null $callback |
| * @return mixed |
| */ |
| public function average($callback = null); |
| |
| /** |
| * Get the median of a given key. |
| * |
| * @param string|array|null $key |
| * @return mixed |
| */ |
| public function median($key = null); |
| |
| /** |
| * Get the mode of a given key. |
| * |
| * @param string|array|null $key |
| * @return array|null |
| */ |
| public function mode($key = null); |
| |
| /** |
| * Collapse the items into a single enumerable. |
| * |
| * @return static |
| */ |
| public function collapse(); |
| |
| /** |
| * Alias for the "contains" method. |
| * |
| * @param mixed $key |
| * @param mixed $operator |
| * @param mixed $value |
| * @return bool |
| */ |
| public function some($key, $operator = null, $value = null); |
| |
| /** |
| * Determine if an item exists, using strict comparison. |
| * |
| * @param mixed $key |
| * @param mixed $value |
| * @return bool |
| */ |
| public function containsStrict($key, $value = null); |
| |
| /** |
| * Get the average value of a given key. |
| * |
| * @param callable|string|null $callback |
| * @return mixed |
| */ |
| public function avg($callback = null); |
| |
| /** |
| * Determine if an item exists in the enumerable. |
| * |
| * @param mixed $key |
| * @param mixed $operator |
| * @param mixed $value |
| * @return bool |
| */ |
| public function contains($key, $operator = null, $value = null); |
| |
| /** |
| * Cross join with the given lists, returning all possible permutations. |
| * |
| * @param mixed ...$lists |
| * @return static |
| */ |
| public function crossJoin(...$lists); |
| |
| /** |
| * Dump the collection and end the script. |
| * |
| * @param mixed ...$args |
| * @return void |
| */ |
| public function dd(...$args); |
| |
| /** |
| * Dump the collection. |
| * |
| * @return $this |
| */ |
| public function dump(); |
| |
| /** |
| * Get the items that are not present in the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function diff($items); |
| |
| /** |
| * Get the items that are not present in the given items, using the callback. |
| * |
| * @param mixed $items |
| * @param callable $callback |
| * @return static |
| */ |
| public function diffUsing($items, callable $callback); |
| |
| /** |
| * Get the items whose keys and values are not present in the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function diffAssoc($items); |
| |
| /** |
| * Get the items whose keys and values are not present in the given items, using the callback. |
| * |
| * @param mixed $items |
| * @param callable $callback |
| * @return static |
| */ |
| public function diffAssocUsing($items, callable $callback); |
| |
| /** |
| * Get the items whose keys are not present in the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function diffKeys($items); |
| |
| /** |
| * Get the items whose keys are not present in the given items, using the callback. |
| * |
| * @param mixed $items |
| * @param callable $callback |
| * @return static |
| */ |
| public function diffKeysUsing($items, callable $callback); |
| |
| /** |
| * Retrieve duplicate items. |
| * |
| * @param callable|null $callback |
| * @param bool $strict |
| * @return static |
| */ |
| public function duplicates($callback = null, $strict = false); |
| |
| /** |
| * Retrieve duplicate items using strict comparison. |
| * |
| * @param callable|null $callback |
| * @return static |
| */ |
| public function duplicatesStrict($callback = null); |
| |
| /** |
| * Execute a callback over each item. |
| * |
| * @param callable $callback |
| * @return $this |
| */ |
| public function each(callable $callback); |
| |
| /** |
| * Execute a callback over each nested chunk of items. |
| * |
| * @param callable $callback |
| * @return static |
| */ |
| public function eachSpread(callable $callback); |
| |
| /** |
| * Determine if all items pass the given truth test. |
| * |
| * @param string|callable $key |
| * @param mixed $operator |
| * @param mixed $value |
| * @return bool |
| */ |
| public function every($key, $operator = null, $value = null); |
| |
| /** |
| * Get all items except for those with the specified keys. |
| * |
| * @param mixed $keys |
| * @return static |
| */ |
| public function except($keys); |
| |
| /** |
| * Run a filter over each of the items. |
| * |
| * @param callable|null $callback |
| * @return static |
| */ |
| public function filter(callable $callback = null); |
| |
| /** |
| * Apply the callback if the value is truthy. |
| * |
| * @param bool $value |
| * @param callable $callback |
| * @param callable|null $default |
| * @return static|mixed |
| */ |
| public function when($value, callable $callback, callable $default = null); |
| |
| /** |
| * Apply the callback if the collection is empty. |
| * |
| * @param callable $callback |
| * @param callable|null $default |
| * @return static|mixed |
| */ |
| public function whenEmpty(callable $callback, callable $default = null); |
| |
| /** |
| * Apply the callback if the collection is not empty. |
| * |
| * @param callable $callback |
| * @param callable|null $default |
| * @return static|mixed |
| */ |
| public function whenNotEmpty(callable $callback, callable $default = null); |
| |
| /** |
| * Apply the callback if the value is falsy. |
| * |
| * @param bool $value |
| * @param callable $callback |
| * @param callable|null $default |
| * @return static|mixed |
| */ |
| public function unless($value, callable $callback, callable $default = null); |
| |
| /** |
| * Apply the callback unless the collection is empty. |
| * |
| * @param callable $callback |
| * @param callable|null $default |
| * @return static|mixed |
| */ |
| public function unlessEmpty(callable $callback, callable $default = null); |
| |
| /** |
| * Apply the callback unless the collection is not empty. |
| * |
| * @param callable $callback |
| * @param callable|null $default |
| * @return static|mixed |
| */ |
| public function unlessNotEmpty(callable $callback, callable $default = null); |
| |
| /** |
| * Filter items by the given key value pair. |
| * |
| * @param string $key |
| * @param mixed $operator |
| * @param mixed $value |
| * @return static |
| */ |
| public function where($key, $operator = null, $value = null); |
| |
| /** |
| * Filter items where the value for the given key is null. |
| * |
| * @param string|null $key |
| * @return static |
| */ |
| public function whereNull($key = null); |
| |
| /** |
| * Filter items where the value for the given key is not null. |
| * |
| * @param string|null $key |
| * @return static |
| */ |
| public function whereNotNull($key = null); |
| |
| /** |
| * Filter items by the given key value pair using strict comparison. |
| * |
| * @param string $key |
| * @param mixed $value |
| * @return static |
| */ |
| public function whereStrict($key, $value); |
| |
| /** |
| * Filter items by the given key value pair. |
| * |
| * @param string $key |
| * @param mixed $values |
| * @param bool $strict |
| * @return static |
| */ |
| public function whereIn($key, $values, $strict = false); |
| |
| /** |
| * Filter items by the given key value pair using strict comparison. |
| * |
| * @param string $key |
| * @param mixed $values |
| * @return static |
| */ |
| public function whereInStrict($key, $values); |
| |
| /** |
| * Filter items such that the value of the given key is between the given values. |
| * |
| * @param string $key |
| * @param array $values |
| * @return static |
| */ |
| public function whereBetween($key, $values); |
| |
| /** |
| * Filter items such that the value of the given key is not between the given values. |
| * |
| * @param string $key |
| * @param array $values |
| * @return static |
| */ |
| public function whereNotBetween($key, $values); |
| |
| /** |
| * Filter items by the given key value pair. |
| * |
| * @param string $key |
| * @param mixed $values |
| * @param bool $strict |
| * @return static |
| */ |
| public function whereNotIn($key, $values, $strict = false); |
| |
| /** |
| * Filter items by the given key value pair using strict comparison. |
| * |
| * @param string $key |
| * @param mixed $values |
| * @return static |
| */ |
| public function whereNotInStrict($key, $values); |
| |
| /** |
| * Filter the items, removing any items that don't match the given type(s). |
| * |
| * @param string|string[] $type |
| * @return static |
| */ |
| public function whereInstanceOf($type); |
| |
| /** |
| * Get the first item from the enumerable passing the given truth test. |
| * |
| * @param callable|null $callback |
| * @param mixed $default |
| * @return mixed |
| */ |
| public function first(callable $callback = null, $default = null); |
| |
| /** |
| * Get the first item by the given key value pair. |
| * |
| * @param string $key |
| * @param mixed $operator |
| * @param mixed $value |
| * @return mixed |
| */ |
| public function firstWhere($key, $operator = null, $value = null); |
| |
| /** |
| * Get a flattened array of the items in the collection. |
| * |
| * @param int $depth |
| * @return static |
| */ |
| public function flatten($depth = INF); |
| |
| /** |
| * Flip the values with their keys. |
| * |
| * @return static |
| */ |
| public function flip(); |
| |
| /** |
| * Get an item from the collection by key. |
| * |
| * @param mixed $key |
| * @param mixed $default |
| * @return mixed |
| */ |
| public function get($key, $default = null); |
| |
| /** |
| * Group an associative array by a field or using a callback. |
| * |
| * @param array|callable|string $groupBy |
| * @param bool $preserveKeys |
| * @return static |
| */ |
| public function groupBy($groupBy, $preserveKeys = false); |
| |
| /** |
| * Key an associative array by a field or using a callback. |
| * |
| * @param callable|string $keyBy |
| * @return static |
| */ |
| public function keyBy($keyBy); |
| |
| /** |
| * Determine if an item exists in the collection by key. |
| * |
| * @param mixed $key |
| * @return bool |
| */ |
| public function has($key); |
| |
| /** |
| * Concatenate values of a given key as a string. |
| * |
| * @param string $value |
| * @param string|null $glue |
| * @return string |
| */ |
| public function implode($value, $glue = null); |
| |
| /** |
| * Intersect the collection with the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function intersect($items); |
| |
| /** |
| * Intersect the collection with the given items by key. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function intersectByKeys($items); |
| |
| /** |
| * Determine if the collection is empty or not. |
| * |
| * @return bool |
| */ |
| public function isEmpty(); |
| |
| /** |
| * Determine if the collection is not empty. |
| * |
| * @return bool |
| */ |
| public function isNotEmpty(); |
| |
| /** |
| * Join all items from the collection using a string. The final items can use a separate glue string. |
| * |
| * @param string $glue |
| * @param string $finalGlue |
| * @return string |
| */ |
| public function join($glue, $finalGlue = ''); |
| |
| /** |
| * Get the keys of the collection items. |
| * |
| * @return static |
| */ |
| public function keys(); |
| |
| /** |
| * Get the last item from the collection. |
| * |
| * @param callable|null $callback |
| * @param mixed $default |
| * @return mixed |
| */ |
| public function last(callable $callback = null, $default = null); |
| |
| /** |
| * Run a map over each of the items. |
| * |
| * @param callable $callback |
| * @return static |
| */ |
| public function map(callable $callback); |
| |
| /** |
| * Run a map over each nested chunk of items. |
| * |
| * @param callable $callback |
| * @return static |
| */ |
| public function mapSpread(callable $callback); |
| |
| /** |
| * Run a dictionary map over the items. |
| * |
| * The callback should return an associative array with a single key/value pair. |
| * |
| * @param callable $callback |
| * @return static |
| */ |
| public function mapToDictionary(callable $callback); |
| |
| /** |
| * Run a grouping map over the items. |
| * |
| * The callback should return an associative array with a single key/value pair. |
| * |
| * @param callable $callback |
| * @return static |
| */ |
| public function mapToGroups(callable $callback); |
| |
| /** |
| * Run an associative map over each of the items. |
| * |
| * The callback should return an associative array with a single key/value pair. |
| * |
| * @param callable $callback |
| * @return static |
| */ |
| public function mapWithKeys(callable $callback); |
| |
| /** |
| * Map a collection and flatten the result by a single level. |
| * |
| * @param callable $callback |
| * @return static |
| */ |
| public function flatMap(callable $callback); |
| |
| /** |
| * Map the values into a new class. |
| * |
| * @param string $class |
| * @return static |
| */ |
| public function mapInto($class); |
| |
| /** |
| * Merge the collection with the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function merge($items); |
| |
| /** |
| * Recursively merge the collection with the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function mergeRecursive($items); |
| |
| /** |
| * Create a collection by using this collection for keys and another for its values. |
| * |
| * @param mixed $values |
| * @return static |
| */ |
| public function combine($values); |
| |
| /** |
| * Union the collection with the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function union($items); |
| |
| /** |
| * Get the min value of a given key. |
| * |
| * @param callable|string|null $callback |
| * @return mixed |
| */ |
| public function min($callback = null); |
| |
| /** |
| * Get the max value of a given key. |
| * |
| * @param callable|string|null $callback |
| * @return mixed |
| */ |
| public function max($callback = null); |
| |
| /** |
| * Create a new collection consisting of every n-th element. |
| * |
| * @param int $step |
| * @param int $offset |
| * @return static |
| */ |
| public function nth($step, $offset = 0); |
| |
| /** |
| * Get the items with the specified keys. |
| * |
| * @param mixed $keys |
| * @return static |
| */ |
| public function only($keys); |
| |
| /** |
| * "Paginate" the collection by slicing it into a smaller collection. |
| * |
| * @param int $page |
| * @param int $perPage |
| * @return static |
| */ |
| public function forPage($page, $perPage); |
| |
| /** |
| * Partition the collection into two arrays using the given callback or key. |
| * |
| * @param callable|string $key |
| * @param mixed $operator |
| * @param mixed $value |
| * @return static |
| */ |
| public function partition($key, $operator = null, $value = null); |
| |
| /** |
| * Push all of the given items onto the collection. |
| * |
| * @param iterable $source |
| * @return static |
| */ |
| public function concat($source); |
| |
| /** |
| * Get one or a specified number of items randomly from the collection. |
| * |
| * @param int|null $number |
| * @return static|mixed |
| * |
| * @throws \InvalidArgumentException |
| */ |
| public function random($number = null); |
| |
| /** |
| * Reduce the collection to a single value. |
| * |
| * @param callable $callback |
| * @param mixed $initial |
| * @return mixed |
| */ |
| public function reduce(callable $callback, $initial = null); |
| |
| /** |
| * Replace the collection items with the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function replace($items); |
| |
| /** |
| * Recursively replace the collection items with the given items. |
| * |
| * @param mixed $items |
| * @return static |
| */ |
| public function replaceRecursive($items); |
| |
| /** |
| * Reverse items order. |
| * |
| * @return static |
| */ |
| public function reverse(); |
| |
| /** |
| * Search the collection for a given value and return the corresponding key if successful. |
| * |
| * @param mixed $value |
| * @param bool $strict |
| * @return mixed |
| */ |
| public function search($value, $strict = false); |
| |
| /** |
| * Shuffle the items in the collection. |
| * |
| * @param int|null $seed |
| * @return static |
| */ |
| public function shuffle($seed = null); |
| |
| /** |
| * Skip the first {$count} items. |
| * |
| * @param int $count |
| * @return static |
| */ |
| public function skip($count); |
| |
| /** |
| * Skip items in the collection until the given condition is met. |
| * |
| * @param mixed $value |
| * @return static |
| */ |
| public function skipUntil($value); |
| |
| /** |
| * Skip items in the collection while the given condition is met. |
| * |
| * @param mixed $value |
| * @return static |
| */ |
| public function skipWhile($value); |
| |
| /** |
| * Get a slice of items from the enumerable. |
| * |
| * @param int $offset |
| * @param int|null $length |
| * @return static |
| */ |
| public function slice($offset, $length = null); |
| |
| /** |
| * Split a collection into a certain number of groups. |
| * |
| * @param int $numberOfGroups |
| * @return static |
| */ |
| public function split($numberOfGroups); |
| |
| /** |
| * Chunk the collection into chunks of the given size. |
| * |
| * @param int $size |
| * @return static |
| */ |
| public function chunk($size); |
| |
| /** |
| * Chunk the collection into chunks with a callback. |
| * |
| * @param callable $callback |
| * @return static |
| */ |
| public function chunkWhile(callable $callback); |
| |
| /** |
| * Sort through each item with a callback. |
| * |
| * @param callable|null|int $callback |
| * @return static |
| */ |
| public function sort($callback = null); |
| |
| /** |
| * Sort items in descending order. |
| * |
| * @param int $options |
| * @return static |
| */ |
| public function sortDesc($options = SORT_REGULAR); |
| |
| /** |
| * Sort the collection using the given callback. |
| * |
| * @param callable|string $callback |
| * @param int $options |
| * @param bool $descending |
| * @return static |
| */ |
| public function sortBy($callback, $options = SORT_REGULAR, $descending = false); |
| |
| /** |
| * Sort the collection in descending order using the given callback. |
| * |
| * @param callable|string $callback |
| * @param int $options |
| * @return static |
| */ |
| public function sortByDesc($callback, $options = SORT_REGULAR); |
| |
| /** |
| * Sort the collection keys. |
| * |
| * @param int $options |
| * @param bool $descending |
| * @return static |
| */ |
| public function sortKeys($options = SORT_REGULAR, $descending = false); |
| |
| /** |
| * Sort the collection keys in descending order. |
| * |
| * @param int $options |
| * @return static |
| */ |
| public function sortKeysDesc($options = SORT_REGULAR); |
| |
| /** |
| * Get the sum of the given values. |
| * |
| * @param callable|string|null $callback |
| * @return mixed |
| */ |
| public function sum($callback = null); |
| |
| /** |
| * Take the first or last {$limit} items. |
| * |
| * @param int $limit |
| * @return static |
| */ |
| public function take($limit); |
| |
| /** |
| * Take items in the collection until the given condition is met. |
| * |
| * @param mixed $value |
| * @return static |
| */ |
| public function takeUntil($value); |
| |
| /** |
| * Take items in the collection while the given condition is met. |
| * |
| * @param mixed $value |
| * @return static |
| */ |
| public function takeWhile($value); |
| |
| /** |
| * Pass the collection to the given callback and then return it. |
| * |
| * @param callable $callback |
| * @return $this |
| */ |
| public function tap(callable $callback); |
| |
| /** |
| * Pass the enumerable to the given callback and return the result. |
| * |
| * @param callable $callback |
| * @return mixed |
| */ |
| public function pipe(callable $callback); |
| |
| /** |
| * Get the values of a given key. |
| * |
| * @param string|array $value |
| * @param string|null $key |
| * @return static |
| */ |
| public function pluck($value, $key = null); |
| |
| /** |
| * Create a collection of all elements that do not pass a given truth test. |
| * |
| * @param callable|mixed $callback |
| * @return static |
| */ |
| public function reject($callback = true); |
| |
| /** |
| * Return only unique items from the collection array. |
| * |
| * @param string|callable|null $key |
| * @param bool $strict |
| * @return static |
| */ |
| public function unique($key = null, $strict = false); |
| |
| /** |
| * Return only unique items from the collection array using strict comparison. |
| * |
| * @param string|callable|null $key |
| * @return static |
| */ |
| public function uniqueStrict($key = null); |
| |
| /** |
| * Reset the keys on the underlying array. |
| * |
| * @return static |
| */ |
| public function values(); |
| |
| /** |
| * Pad collection to the specified length with a value. |
| * |
| * @param int $size |
| * @param mixed $value |
| * @return static |
| */ |
| public function pad($size, $value); |
| |
| /** |
| * Count the number of items in the collection using a given truth test. |
| * |
| * @param callable|null $callback |
| * @return static |
| */ |
| public function countBy($callback = null); |
| |
| /** |
| * Zip the collection together with one or more arrays. |
| * |
| * e.g. new Collection([1, 2, 3])->zip([4, 5, 6]); |
| * => [[1, 4], [2, 5], [3, 6]] |
| * |
| * @param mixed ...$items |
| * @return static |
| */ |
| public function zip($items); |
| |
| /** |
| * Collect the values into a collection. |
| * |
| * @return \Tightenco\Collect\Support\Collection |
| */ |
| public function collect(); |
| |
| /** |
| * Convert the collection to its string representation. |
| * |
| * @return string |
| */ |
| public function __toString(); |
| |
| /** |
| * Add a method to the list of proxied methods. |
| * |
| * @param string $method |
| * @return void |
| */ |
| public static function proxy($method); |
| |
| /** |
| * Dynamically access collection proxies. |
| * |
| * @param string $key |
| * @return mixed |
| * |
| * @throws \Exception |
| */ |
| public function __get($key); |
| } |