DatabaseNotificationCollection
class DatabaseNotificationCollection extends Collection (View source)
Traits
Properties
Methods
Create a new collection instance if the value isn't one already.
Wrap the given value in a collection if applicable.
Get the underlying items from the given collection if applicable.
Alias for the "avg" method.
Alias for the "contains" method.
Determine if an item exists, using strict comparison.
Execute a callback over each nested chunk of items.
Determine if all items pass the given truth test.
Get the first item by the given key value pair.
Run a map over each nested chunk of items.
Run a grouping map over the items.
Map a collection and flatten the result by a single level.
Get the min value of a given key.
Get the max value of a given key.
"Paginate" the collection by slicing it into a smaller collection.
Partition the collection into two arrays using the given callback or key.
Get the sum of the given values.
Apply the callback if the value is truthy.
Apply the callback if the collection is empty.
Apply the callback if the collection is not empty.
Apply the callback if the value is falsy.
Apply the callback unless the collection is empty.
Apply the callback unless the collection is not empty.
Filter items by the given key value pair.
Filter items where the given key is not null.
Filter items where the given key is null.
Filter items by the given key value pair using strict comparison.
Filter items by the given key value pair.
Filter items by the given key value pair using strict comparison.
Filter items such that the value of the given key is between the given values.
Filter items such that the value of the given key is not between the given values.
Filter items by the given key value pair.
Filter items by the given key value pair using strict comparison.
Filter the items, removing any items that don't match the given type.
Pass the collection to the given callback and return the result.
Pass the collection to the given callback and then return it.
Create a collection of all elements that do not pass a given truth test.
Return only unique items from the collection array.
Return only unique items from the collection array using strict comparison.
Get a CachingIterator instance.
Count the number of items in the collection using a given truth test.
Add a method to the list of proxied methods.
Results array of items from Collection or Arrayable.
Get an operator checker callback.
Determine if the given value is callable, but not a string.
Get a value retrieving callback.
Mix another object into the class.
Dynamically handle calls to the class.
Dynamically handle calls to the class.
Create a new instance by invoking the callback a given amount of times.
Get the average value of a given key.
Determine if a key exists in the collection.
Cross join with the given lists, returning all possible permutations.
Get the items that are not present in the given items, using the callback.
Get the items whose keys and values are not present in the given items.
Get the items whose keys and values are not present in the given items, using the callback.
Get the items whose keys are not present in the given items.
Get the items whose keys are not present in the given items, using the callback.
Retrieve duplicate items.
Retrieve duplicate items using strict comparison.
Get the comparison function to detect duplicates.
Returns all models in the collection except the models with specified keys.
Get the first item from the enumerable passing the given truth test.
Get a flattened array of the items in the collection.
Get an item from the collection by key.
Group an associative array by a field or using a callback.
Key an associative array by a field or using a callback.
Concatenate values of a given key as a string.
Intersect the collection with the given items by key.
Join all items from the collection using a string. The final items can use a separate glue string.
Get the last item from the collection.
Get an array with the values of a given key.
Run an associative map over each of the items.
Recursively merge the collection with the given items.
Create a collection by using this collection for keys and another for its values.
Create a new collection consisting of every n-th element.
Returns only the models from the collection with the specified keys.
Push an item onto the beginning of the collection.
Push all of the given items onto the collection.
Get and remove an item from the collection.
Get one or a specified number of items randomly from the collection.
Reduce the collection to a single value.
Recursively replace the collection items with the given items.
Search the collection for a given value and return the corresponding key if successful.
Get a slice of items from the enumerable.
Split a collection into a certain number of groups.
Sort the collection using the given callback.
Sort the collection in descending order using the given callback.
Sort the collection keys.
Sort the collection keys in descending order.
Splice a portion of the underlying collection array.
Transform each item in the collection using a callback.
Pad collection to the specified length with a value.
Find a model in the collection by key.
Load a set of relationships onto the collection.
Load a set of relationship counts onto the collection.
Load a set of relationships onto the collection if they are not already eager loaded.
Load a relationship path if it is not already eager loaded.
Load a set of relationships onto the mixed relationship collection.
Reload a fresh model instance from the database for all the entities.
Make the given, typically visible, attributes hidden across the entire collection.
Make the given, typically hidden, attributes visible across the entire collection.
Get the connection of the entities being queued.
Mark all notifications as read.
Mark all notifications as unread.
Details
        
                static            EnumeratesValues
    make(mixed $items = [])
        
    
    Create a new collection instance if the value isn't one already.
        
                static            EnumeratesValues
    wrap(mixed $value)
        
    
    Wrap the given value in a collection if applicable.
        
                static            array
    unwrap(array|EnumeratesValues $value)
        
    
    Get the underlying items from the given collection if applicable.
        
                            mixed
    average(callable|string|null $callback = null)
        
    
    Alias for the "avg" method.
        
                            bool
    some(mixed $key, mixed $operator = null, mixed $value = null)
        
    
    Alias for the "contains" method.
        
                            bool
    containsStrict(mixed $key, mixed $value = null)
        
    
    Determine if an item exists, using strict comparison.
        
                            void
    dd(mixed ...$args)
        
    
    Dump the items and end the script.
        
                            $this
    dump()
        
    
    Dump the items.
        
                            $this
    each(callable $callback)
        
    
    Execute a callback over each item.
        
                            EnumeratesValues
    eachSpread(callable $callback)
        
    
    Execute a callback over each nested chunk of items.
        
                            bool
    every(string|callable $key, mixed $operator = null, mixed $value = null)
        
    
    Determine if all items pass the given truth test.
        
                            mixed
    firstWhere(string $key, mixed $operator = null, mixed $value = null)
        
    
    Get the first item by the given key value pair.
        
                            bool
    isNotEmpty()
        
    
    Determine if the collection is not empty.
        
                            EnumeratesValues
    mapSpread(callable $callback)
        
    
    Run a map over each nested chunk of items.
        
                            EnumeratesValues
    mapToGroups(callable $callback)
        
    
    Run a grouping map over the items.
The callback should return an associative array with a single key/value pair.
        
                            EnumeratesValues
    flatMap(callable $callback)
        
    
    Map a collection and flatten the result by a single level.
        
                            EnumeratesValues
    mapInto(string $class)
        
    
    Map the values into a new class.
        
                            mixed
    min(callable|string|null $callback = null)
        
    
    Get the min value of a given key.
        
                            mixed
    max(callable|string|null $callback = null)
        
    
    Get the max value of a given key.
        
                            EnumeratesValues
    forPage(int $page, int $perPage)
        
    
    "Paginate" the collection by slicing it into a smaller collection.
        
                            EnumeratesValues
    partition(callable|string $key, mixed $operator = null, mixed $value = null)
        
    
    Partition the collection into two arrays using the given callback or key.
        
                            mixed
    sum(callable|string|null $callback = null)
        
    
    Get the sum of the given values.
        
                            EnumeratesValues|mixed
    when(bool|mixed $value, callable $callback, callable $default = null)
        
    
    Apply the callback if the value is truthy.
        
                            EnumeratesValues|mixed
    whenEmpty(callable $callback, callable $default = null)
        
    
    Apply the callback if the collection is empty.
        
                            EnumeratesValues|mixed
    whenNotEmpty(callable $callback, callable $default = null)
        
    
    Apply the callback if the collection is not empty.
        
                            EnumeratesValues|mixed
    unless(bool $value, callable $callback, callable $default = null)
        
    
    Apply the callback if the value is falsy.
        
                            EnumeratesValues|mixed
    unlessEmpty(callable $callback, callable $default = null)
        
    
    Apply the callback unless the collection is empty.
        
                            EnumeratesValues|mixed
    unlessNotEmpty(callable $callback, callable $default = null)
        
    
    Apply the callback unless the collection is not empty.
        
                            EnumeratesValues
    where(string $key, mixed $operator = null, mixed $value = null)
        
    
    Filter items by the given key value pair.
        
                            EnumeratesValues
    whereNull(string|null $key = null)
        
    
    Filter items where the given key is not null.
        
                            EnumeratesValues
    whereNotNull(string|null $key = null)
        
    
    Filter items where the given key is null.
        
                            EnumeratesValues
    whereStrict(string $key, mixed $value)
        
    
    Filter items by the given key value pair using strict comparison.
        
                            EnumeratesValues
    whereIn(string $key, mixed $values, bool $strict = false)
        
    
    Filter items by the given key value pair.
        
                            EnumeratesValues
    whereInStrict(string $key, mixed $values)
        
    
    Filter items by the given key value pair using strict comparison.
        
                            EnumeratesValues
    whereBetween(string $key, array $values)
        
    
    Filter items such that the value of the given key is between the given values.
        
                            EnumeratesValues
    whereNotBetween(string $key, array $values)
        
    
    Filter items such that the value of the given key is not between the given values.
        
                            EnumeratesValues
    whereNotIn(string $key, mixed $values, bool $strict = false)
        
    
    Filter items by the given key value pair.
        
                            EnumeratesValues
    whereNotInStrict(string $key, mixed $values)
        
    
    Filter items by the given key value pair using strict comparison.
        
                            EnumeratesValues
    whereInstanceOf(string $type)
        
    
    Filter the items, removing any items that don't match the given type.
        
                            mixed
    pipe(callable $callback)
        
    
    Pass the collection to the given callback and return the result.
        
                            $this
    tap(callable $callback)
        
    
    Pass the collection to the given callback and then return it.
        
                            EnumeratesValues
    reject(callable|mixed $callback = true)
        
    
    Create a collection of all elements that do not pass a given truth test.
        
                            EnumeratesValues
    unique(string|callable|null $key = null, bool $strict = false)
        
    
    Return only unique items from the collection array.
        
                            EnumeratesValues
    uniqueStrict(string|callable|null $key = null)
        
    
    Return only unique items from the collection array using strict comparison.
        
                            Collection
    collect()
        
    
    Collect the values into a collection.
        
                            array
    toArray()
        
    
    Get the collection of items as a plain array.
        
                            array
    jsonSerialize()
        
    
    Convert the object into something JSON serializable.
        
                            string
    toJson(int $options = 0)
        
    
    Get the collection of items as JSON.
        
                            CachingIterator
    getCachingIterator(int $flags = CachingIterator::CALL_TOSTRING)
        
    
    Get a CachingIterator instance.
        
                            EnumeratesValues
    countBy(callable|null $callback = null)
        
    
    Count the number of items in the collection using a given truth test.
        
                            string
    __toString()
        
    
    Convert the collection to its string representation.
        
                static            void
    proxy(string $method)
        
    
    Add a method to the list of proxied methods.
        
                            mixed
    __get(string $key)
        
    
    Dynamically access collection proxies.
        
                    protected        array
    getArrayableItems(mixed $items)
        
    
    Results array of items from Collection or Arrayable.
        
                    protected        Closure
    operatorForWhere(string $key, string|null $operator = null, mixed $value = null)
        
    
    Get an operator checker callback.
        
                    protected        bool
    useAsCallable(mixed $value)
        
    
    Determine if the given value is callable, but not a string.
        
                    protected        callable
    valueRetriever(callable|string|null $value)
        
    
    Get a value retrieving callback.
        
                static            void
    macro(string $name, object|callable $macro)
        
    
    Register a custom macro.
        
                static            void
    mixin(object $mixin, bool $replace = true)
        
    
    Mix another object into the class.
        
                static            bool
    hasMacro(string $name)
        
    
    Checks if macro is registered.
        
                static            mixed
    __callStatic(string $method, array $parameters)
        
    
    Dynamically handle calls to the class.
        
                            mixed
    __call(string $method, array $parameters)
        
    
    Dynamically handle calls to the class.
        
                            void
    __construct(mixed $items = [])
        
    
    Create a new collection.
        
                static            Enumerable
    times(int $number, callable $callback = null)
        
    
    Create a new instance by invoking the callback a given amount of times.
        
                            array
    all()
        
    
    Get all items in the enumerable.
        
                            LazyCollection
    lazy()
        
    
    Get a lazy collection for the items in this collection.
        
                            mixed
    avg(callable|string|null $callback = null)
        
    
    Get the average value of a given key.
        
                            mixed
    median(string|array|null $key = null)
        
    
    Get the median of a given key.
        
                            array|null
    mode(string|array|null $key = null)
        
    
    Get the mode of a given key.
        
                            Enumerable
    collapse()
        
    
    Collapse the collection of items into a single array.
        
                            bool
    contains(mixed $key, mixed $operator = null, mixed $value = null)
        
    
    Determine if a key exists in the collection.
        
                            Collection
    crossJoin(mixed ...$lists)
        
    
    Cross join with the given lists, returning all possible permutations.
        
                            Enumerable
    diff(mixed $items)
        
    
    Diff the collection with the given items.
        
                            Enumerable
    diffUsing(mixed $items, callable $callback)
        
    
    Get the items that are not present in the given items, using the callback.
        
                            Enumerable
    diffAssoc(mixed $items)
        
    
    Get the items whose keys and values are not present in the given items.
        
                            Enumerable
    diffAssocUsing(mixed $items, callable $callback)
        
    
    Get the items whose keys and values are not present in the given items, using the callback.
        
                            Enumerable
    diffKeys(mixed $items)
        
    
    Get the items whose keys are not present in the given items.
        
                            Enumerable
    diffKeysUsing(mixed $items, callable $callback)
        
    
    Get the items whose keys are not present in the given items, using the callback.
        
                            Enumerable
    duplicates(callable|null $callback = null, bool $strict = false)
        
    
    Retrieve duplicate items.
        
                            Enumerable
    duplicatesStrict(callable|null $callback = null)
        
    
    Retrieve duplicate items using strict comparison.
        
                    protected        Closure
    duplicateComparator(bool $strict)
        
    
    Get the comparison function to detect duplicates.
        
                            Enumerable
    except(mixed $keys)
        
    
    Returns all models in the collection except the models with specified keys.
        
                            Enumerable
    filter(callable $callback = null)
        
    
    Run a filter over each of the items.
        
                            mixed
    first(callable $callback = null, mixed $default = null)
        
    
    Get the first item from the enumerable passing the given truth test.
        
                            Collection
    flatten(int $depth = INF)
        
    
    Get a flattened array of the items in the collection.
        
                            Enumerable
    flip()
        
    
    Flip the items in the collection.
        
                            $this
    forget(string|array $keys)
        
    
    Remove an item from the collection by key.
        
                            mixed
    get(mixed $key, mixed $default = null)
        
    
    Get an item from the collection by key.
        
                            Enumerable
    groupBy(array|callable|string $groupBy, bool $preserveKeys = false)
        
    
    Group an associative array by a field or using a callback.
        
                            Enumerable
    keyBy(callable|string $keyBy)
        
    
    Key an associative array by a field or using a callback.
        
                            bool
    has(mixed $key)
        
    
    Determine if an item exists in the collection by key.
        
                            string
    implode(string $value, string $glue = null)
        
    
    Concatenate values of a given key as a string.
        
                            Enumerable
    intersect(mixed $items)
        
    
    Intersect the collection with the given items.
        
                            Enumerable
    intersectByKeys(mixed $items)
        
    
    Intersect the collection with the given items by key.
        
                            bool
    isEmpty()
        
    
    Determine if the collection is empty or not.
        
                            string
    join(string $glue, string $finalGlue = '')
        
    
    Join all items from the collection using a string. The final items can use a separate glue string.
        
                            Enumerable
    keys()
        
    
    Get the keys of the collection items.
        
                            mixed
    last(callable $callback = null, mixed $default = null)
        
    
    Get the last item from the collection.
        
                            Enumerable
    pluck(string|array $value, string|null $key = null)
        
    
    Get an array with the values of a given key.
        
                            Enumerable
    map(callable $callback)
        
    
    Run a map over each of the items.
        
                            Enumerable
    mapToDictionary(callable $callback)
        
    
    Run a dictionary map over the items.
The callback should return an associative array with a single key/value pair.
        
                            Enumerable
    mapWithKeys(callable $callback)
        
    
    Run an associative map over each of the items.
The callback should return an associative array with a single key / value pair.
        
                            Enumerable
    merge(mixed $items)
        
    
    Merge the collection with the given items.
        
                            Enumerable
    mergeRecursive(mixed $items)
        
    
    Recursively merge the collection with the given items.
        
                            Enumerable
    combine(mixed $values)
        
    
    Create a collection by using this collection for keys and another for its values.
        
                            Enumerable
    union(mixed $items)
        
    
    Union the collection with the given items.
        
                            Enumerable
    nth(int $step, int $offset = 0)
        
    
    Create a new collection consisting of every n-th element.
        
                            Enumerable
    only(mixed $keys)
        
    
    Returns only the models from the collection with the specified keys.
        
                            mixed
    pop()
        
    
    Get and remove the last item from the collection.
        
                            $this
    prepend(mixed $value, mixed $key = null)
        
    
    Push an item onto the beginning of the collection.
        
                            $this
    push(mixed $value)
        
    
    Push an item onto the end of the collection.
        
                            Enumerable
    concat(iterable $source)
        
    
    Push all of the given items onto the collection.
        
                            mixed
    pull(mixed $key, mixed $default = null)
        
    
    Get and remove an item from the collection.
        
                            $this
    put(mixed $key, mixed $value)
        
    
    Put an item in the collection by key.
        
                            Enumerable|mixed
    random(int|null $number = null)
        
    
    Get one or a specified number of items randomly from the collection.
        
                            mixed
    reduce(callable $callback, mixed $initial = null)
        
    
    Reduce the collection to a single value.
        
                            Enumerable
    replace(mixed $items)
        
    
    Replace the collection items with the given items.
        
                            Enumerable
    replaceRecursive(mixed $items)
        
    
    Recursively replace the collection items with the given items.
        
                            Enumerable
    reverse()
        
    
    Reverse items order.
        
                            mixed
    search(mixed $value, bool $strict = false)
        
    
    Search the collection for a given value and return the corresponding key if successful.
        
                            mixed
    shift()
        
    
    Get and remove the first item from the collection.
        
                            Enumerable
    shuffle(int $seed = null)
        
    
    Shuffle the items in the collection.
        
                            Enumerable
    skip(int $count)
        
    
    Skip the first {$count} items.
        
                            Enumerable
    slice(int $offset, int $length = null)
        
    
    Get a slice of items from the enumerable.
        
                            Enumerable
    split(int $numberOfGroups)
        
    
    Split a collection into a certain number of groups.
        
                            Enumerable
    chunk(int $size)
        
    
    Chunk the collection into chunks of the given size.
        
                            Enumerable
    sort(callable $callback = null)
        
    
    Sort through each item with a callback.
        
                            Enumerable
    sortBy(callable|string $callback, int $options = SORT_REGULAR, bool $descending = false)
        
    
    Sort the collection using the given callback.
        
                            Enumerable
    sortByDesc(callable|string $callback, int $options = SORT_REGULAR)
        
    
    Sort the collection in descending order using the given callback.
        
                            Enumerable
    sortKeys(int $options = SORT_REGULAR, bool $descending = false)
        
    
    Sort the collection keys.
        
                            Enumerable
    sortKeysDesc(int $options = SORT_REGULAR)
        
    
    Sort the collection keys in descending order.
        
                            Collection
    splice(int $offset, int|null $length = null, mixed $replacement = [])
        
    
    Splice a portion of the underlying collection array.
        
                            Enumerable
    take(int $limit)
        
    
    Take the first or last {$limit} items.
        
                            $this
    transform(callable $callback)
        
    
    Transform each item in the collection using a callback.
        
                            Enumerable
    values()
        
    
    Reset the keys on the underlying array.
        
                            Collection
    zip(mixed $items)
        
    
    Zip the collection together with one or more arrays.
        
                            Enumerable
    pad(int $size, mixed $value)
        
    
    Pad collection to the specified length with a value.
        
                            ArrayIterator
    getIterator()
        
    
    Get an iterator for the items.
        
                            int
    count()
        
    
    Count the number of items in the collection.
        
                            $this
    add(mixed $item)
        
    
    Add an item to the collection.
        
                            Collection
    toBase()
        
    
    Get a base Support collection instance from this collection.
        
                            bool
    offsetExists(mixed $key)
        
    
    Determine if an item exists at an offset.
        
                            mixed
    offsetGet(mixed $key)
        
    
    Get an item at a given offset.
        
                            void
    offsetSet(mixed $key, mixed $value)
        
    
    Set the item at a given offset.
        
                            void
    offsetUnset(string $key)
        
    
    Unset the item at a given offset.
        
                            Model|Collection|null
    find(mixed $key, mixed $default = null)
        
    
    Find a model in the collection by key.
        
                            $this
    load(array|string $relations)
        
    
    Load a set of relationships onto the collection.
        
                            $this
    loadCount(array|string $relations)
        
    
    Load a set of relationship counts onto the collection.
        
                            $this
    loadMissing(array|string $relations)
        
    
    Load a set of relationships onto the collection if they are not already eager loaded.
        
                    protected        void
    loadMissingRelation(Collection $models, array $path)
        
    
    Load a relationship path if it is not already eager loaded.
        
                            $this
    loadMorph(string $relation, array $relations)
        
    
    Load a set of relationships onto the mixed relationship collection.
        
                            array
    modelKeys()
        
    
    Get the array of primary keys.
        
                            Collection
    fresh(array|string $with = [])
        
    
    Reload a fresh model instance from the database for all the entities.
        
                            $this
    makeHidden(array|string $attributes)
        
    
    Make the given, typically visible, attributes hidden across the entire collection.
        
                            $this
    makeVisible(array|string $attributes)
        
    
    Make the given, typically hidden, attributes visible across the entire collection.
        
                            array
    getDictionary(ArrayAccess|array|null $items = null)
        
    
    Get a dictionary keyed by primary keys.
        
                            string|null
    getQueueableClass()
        
    
    Get the type of the entities being queued.
        
                            array
    getQueueableIds()
        
    
    Get the identifiers for all of the entities.
        
                            array
    getQueueableRelations()
        
    
    Get the relationships of the entities being queued.
        
                            string|null
    getQueueableConnection()
        
    
    Get the connection of the entities being queued.
        
                            void
    markAsRead()
        
    
    Mark all notifications as read.
        
                            void
    markAsUnread()
        
    
    Mark all notifications as unread.