Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Illuminate\Database\Eloquent\Concerns;

use BackedEnum;

use Carbon\CarbonImmutable;

use Carbon\CarbonInterface;

use DateTimeImmutable;

use DateTimeInterface;

use Illuminate\Contracts\Database\Eloquent\Castable;

use Illuminate\Contracts\Database\Eloquent\CastsInboundAttributes;

use Illuminate\Contracts\Support\Arrayable;

use Illuminate\Database\Eloquent\Casts\AsArrayObject;

use Illuminate\Database\Eloquent\Casts\AsCollection;

use Illuminate\Database\Eloquent\Casts\AsEncryptedArrayObject;

use Illuminate\Database\Eloquent\Casts\AsEncryptedCollection;

use Illuminate\Database\Eloquent\Casts\Attribute;

use Illuminate\Database\Eloquent\InvalidCastException;

use Illuminate\Database\Eloquent\JsonEncodingException;

use Illuminate\Database\Eloquent\MissingAttributeException;

use Illuminate\Database\Eloquent\Relations\Relation;

use Illuminate\Database\LazyLoadingViolationException;

use Illuminate\Support\Arr;

use Illuminate\Support\Carbon;

use Illuminate\Support\Collection as BaseCollection;

use Illuminate\Support\Facades\Crypt;

use Illuminate\Support\Facades\Date;

use Illuminate\Support\Str;

use InvalidArgumentException;

use LogicException;

use ReflectionClass;

use ReflectionMethod;

use ReflectionNamedType;

use RuntimeException;

use TypeError;

trait HasAttributes

{

    /**

     * The model's attributes.

     *

     * @var array

     */

    protected $attributes = [];

    /**

     * The model attribute's original state.

     *

     * @var array

     */

    protected $original = [];

    /**

     * The changed model attributes.

     *

     * @var array

     */

    protected $changes = [];

    /**

     * The attributes that should be cast.

     *

     * @var array

     */

    protected $casts = [];

    /**

     * The attributes that have been cast using custom classes.

     *

     * @var array

     */

    protected $classCastCache = [];

    /**

     * The attributes that have been cast using "Attribute" return type mutators.

     *

     * @var array

     */

    protected $attributeCastCache = [];

    /**

     * The built-in, primitive cast types supported by Eloquent.

     *

     * @var string[]

     */

    protected static $primitiveCastTypes = [

        'array',

        'bool',

        'boolean',

        'collection',

        'custom_datetime',

        'date',

        'datetime',

        'decimal',

        'double',

        'encrypted',

        'encrypted:array',

        'encrypted:collection',

        'encrypted:json',

        'encrypted:object',

        'float',

        'immutable_date',

        'immutable_datetime',

        'immutable_custom_datetime',

        'int',

        'integer',

        'json',

        'object',

        'real',

        'string',

        'timestamp',

    ];

    /**

     * The attributes that should be mutated to dates.

     *

     * @deprecated Use the "casts" property

     *

     * @var array

     */

    protected $dates = [];

    /**

     * The storage format of the model's date columns.

     *

     * @var string

     */

    protected $dateFormat;

    /**

     * The accessors to append to the model's array form.

     *

     * @var array

     */

    protected $appends = [];

    /**

     * Indicates whether attributes are snake cased on arrays.

     *

     * @var bool

     */

    public static $snakeAttributes = true;

    /**

     * The cache of the mutated attributes for each class.

     *

     * @var array

     */

    protected static $mutatorCache = [];

    /**

     * The cache of the "Attribute" return type marked mutated attributes for each class.

     *

     * @var array

     */

    protected static $attributeMutatorCache = [];

    /**

     * The cache of the "Attribute" return type marked mutated, gettable attributes for each class.

     *

     * @var array

     */

    protected static $getAttributeMutatorCache = [];

    /**

     * The cache of the "Attribute" return type marked mutated, settable attributes for each class.

     *

     * @var array

     */

    protected static $setAttributeMutatorCache = [];

    /**

     * The cache of the converted cast types.

     *

     * @var array

     */

    protected static $castTypeCache = [];

    /**

     * The encrypter instance that is used to encrypt attributes.

     *

     * @var \Illuminate\Contracts\Encryption\Encrypter|null

     */

    public static $encrypter;

    /**

     * Convert the model's attributes to an array.

     *

     * @return array

     */

    public function attributesToArray()

    {

        // If an attribute is a date, we will cast it to a string after converting it

        // to a DateTime / Carbon instance. This is so we will get some consistent

        // formatting while accessing attributes vs. arraying / JSONing a model.

        $attributes = $this->addDateAttributesToArray(

            $attributes = $this->getArrayableAttributes()

        );

        $attributes = $this->addMutatedAttributesToArray(

            $attributes, $mutatedAttributes = $this->getMutatedAttributes()

        );

        // Next we will handle any casts that have been setup for this model and cast

        // the values to their appropriate type. If the attribute has a mutator we

        // will not perform the cast on those attributes to avoid any confusion.

        $attributes = $this->addCastAttributesToArray(

            $attributes, $mutatedAttributes

        );

        // Here we will grab all of the appended, calculated attributes to this model

        // as these attributes are not really in the attributes array, but are run

        // when we need to array or JSON the model for convenience to the coder.

        foreach ($this->getArrayableAppends() as $key) {

            $attributes[$key] = $this->mutateAttributeForArray($key, null);

        }

        return $attributes;

    }

    /**

     * Add the date attributes to the attributes array.

     *

     * @param  array  $attributes

     * @return array

     */

    protected function addDateAttributesToArray(array $attributes)

    {

        foreach ($this->getDates() as $key) {

            if (! isset($attributes[$key])) {

                continue;

            }

            $attributes[$key] = $this->serializeDate(

                $this->asDateTime($attributes[$key])

            );

        }

        return $attributes;

    }

    /**

     * Add the mutated attributes to the attributes array.

     *

     * @param  array  $attributes

     * @param  array  $mutatedAttributes

     * @return array

     */

    protected function addMutatedAttributesToArray(array $attributes, array $mutatedAttributes)

    {

        foreach ($mutatedAttributes as $key) {

            // We want to spin through all the mutated attributes for this model and call

            // the mutator for the attribute. We cache off every mutated attributes so

            // we don't have to constantly check on attributes that actually change.

            if (! array_key_exists($key, $attributes)) {

                continue;

            }

            // Next, we will call the mutator for this attribute so that we can get these

            // mutated attribute's actual values. After we finish mutating each of the

            // attributes we will return this final array of the mutated attributes.

            $attributes[$key] = $this->mutateAttributeForArray(

                $key, $attributes[$key]

            );

        }

        return $attributes;

    }

    /**

     * Add the casted attributes to the attributes array.

     *

     * @param  array  $attributes

     * @param  array  $mutatedAttributes

     * @return array

     */

    protected function addCastAttributesToArray(array $attributes, array $mutatedAttributes)

    {

        foreach ($this->getCasts() as $key => $value) {

            if (! array_key_exists($key, $attributes) ||

                in_array($key, $mutatedAttributes)) {

                continue;

            }

            // Here we will cast the attribute. Then, if the cast is a date or datetime cast

            // then we will serialize the date for the array. This will convert the dates

            // to strings based on the date format specified for these Eloquent models.

            $attributes[$key] = $this->castAttribute(

                $key, $attributes[$key]

            );

            // If the attribute cast was a date or a datetime, we will serialize the date as

            // a string. This allows the developers to customize how dates are serialized

            // into an array without affecting how they are persisted into the storage.

            if (isset($attributes[$key]) && in_array($value, ['date', 'datetime', 'immutable_date', 'immutable_datetime'])) {

                $attributes[$key] = $this->serializeDate($attributes[$key]);

            }

            if (isset($attributes[$key]) && ($this->isCustomDateTimeCast($value) ||

                $this->isImmutableCustomDateTimeCast($value))) {

                $attributes[$key] = $attributes[$key]->format(explode(':', $value, 2)[1]);

            }

            if ($attributes[$key] instanceof DateTimeInterface &&

                $this->isClassCastable($key)) {

                $attributes[$key] = $this->serializeDate($attributes[$key]);

            }

            if (isset($attributes[$key]) && $this->isClassSerializable($key)) {

                $attributes[$key] = $this->serializeClassCastableAttribute($key, $attributes[$key]);

            }

            if ($this->isEnumCastable($key) && (! ($attributes[$key] ?? null) instanceof Arrayable)) {

                $attributes[$key] = isset($attributes[$key]) ? $this->getStorableEnumValue($attributes[$key]) : null;

            }

            if ($attributes[$key] instanceof Arrayable) {

                $attributes[$key] = $attributes[$key]->toArray();

            }

        }

        return $attributes;

    }

    /**

     * Get an attribute array of all arrayable attributes.

     *

     * @return array

     */

    protected function getArrayableAttributes()

    {

        return $this->getArrayableItems($this->getAttributes());

    }

    /**

     * Get all of the appendable values that are arrayable.

     *

     * @return array

     */

    protected function getArrayableAppends()

    {

        if (! count($this->appends)) {

            return [];

        }

        return $this->getArrayableItems(

            array_combine($this->appends, $this->appends)

        );

    }

    /**

     * Get the model's relationships in array form.

     *

     * @return array

     */

    public function relationsToArray()

    {

        $attributes = [];

        foreach ($this->getArrayableRelations() as $key => $value) {

            // If the values implement the Arrayable interface we can just call this

            // toArray method on the instances which will convert both models and

            // collections to their proper array form and we'll set the values.

            if ($value instanceof Arrayable) {

                $relation = $value->toArray();

            }

            // If the value is null, we'll still go ahead and set it in this list of

            // attributes, since null is used to represent empty relationships if

            // it has a has one or belongs to type relationships on the models.

            elseif (is_null($value)) {

                $relation = $value;

            }

            // If the relationships snake-casing is enabled, we will snake case this

            // key so that the relation attribute is snake cased in this returned

            // array to the developers, making this consistent with attributes.

            if (static::$snakeAttributes) {

                $key = Str::snake($key);

            }

            // If the relation value has been set, we will set it on this attributes

            // list for returning. If it was not arrayable or null, we'll not set

            // the value on the array because it is some type of invalid value.

            if (isset($relation) || is_null($value)) {

                $attributes[$key] = $relation;

            }

            unset($relation);

        }

        return $attributes;

    }

    /**

     * Get an attribute array of all arrayable relations.

     *

     * @return array

     */

    protected function getArrayableRelations()

    {

        return $this->getArrayableItems($this->relations);

    }

    /**

     * Get an attribute array of all arrayable values.

     *

     * @param  array  $values

     * @return array

     */

    protected function getArrayableItems(array $values)

    {

        if (count($this->getVisible()) > 0) {

            $values = array_intersect_key($values, array_flip($this->getVisible()));

        }

        if (count($this->getHidden()) > 0) {

            $values = array_diff_key($values, array_flip($this->getHidden()));

        }

        return $values;

    }

    /**

     * Get an attribute from the model.

     *

     * @param  string  $key

     * @return mixed

     */

    public function getAttribute($key)

    {

        if (! $key) {

            return;

        }

        // If the attribute exists in the attribute array or has a "get" mutator we will

        // get the attribute's value. Otherwise, we will proceed as if the developers

        // are asking for a relationship's value. This covers both types of values.

        if (array_key_exists($key, $this->attributes) ||

            array_key_exists($key, $this->casts) ||

            $this->hasGetMutator($key) ||

            $this->hasAttributeMutator($key) ||

            $this->isClassCastable($key)) {

            return $this->getAttributeValue($key);

        }

        // Here we will determine if the model base class itself contains this given key

        // since we don't want to treat any of those methods as relationships because

        // they are all intended as helper methods and none of these are relations.

        if (method_exists(self::class, $key)) {

            return $this->throwMissingAttributeExceptionIfApplicable($key);

        }

        return $this->isRelation($key) || $this->relationLoaded($key)

                    ? $this->getRelationValue($key)

                    : $this->throwMissingAttributeExceptionIfApplicable($key);

    }

    /**

     * Either throw a missing attribute exception or return null depending on Eloquent's configuration.

     *

     * @param  string  $key

     * @return null

     *

     * @throws \Illuminate\Database\Eloquent\MissingAttributeException

     */

    protected function throwMissingAttributeExceptionIfApplicable($key)

    {

        if ($this->exists &&

            ! $this->wasRecentlyCreated &&

            static::preventsAccessingMissingAttributes()) {

            if (isset(static::$missingAttributeViolationCallback)) {

                return call_user_func(static::$missingAttributeViolationCallback, $this, $key);

            }

            throw new MissingAttributeException($this, $key);

        }

        return null;

    }

    /**

     * Get a plain attribute (not a relationship).

     *

     * @param  string  $key

     * @return mixed

     */

    public function getAttributeValue($key)

    {

        return $this->transformModelValue($key, $this->getAttributeFromArray($key));

    }

    /**

     * Get an attribute from the $attributes array.

     *

     * @param  string  $key

     * @return mixed

     */

    protected function getAttributeFromArray($key)

    {

        return $this->getAttributes()[$key] ?? null;

    }

    /**

     * Get a relationship.

     *

     * @param  string  $key

     * @return mixed

     */

    public function getRelationValue($key)

    {

        // If the key already exists in the relationships array, it just means the

        // relationship has already been loaded, so we'll just return it out of

        // here because there is no need to query within the relations twice.

        if ($this->relationLoaded($key)) {

            return $this->relations[$key];

        }

        if (! $this->isRelation($key)) {

            return;

        }

        if ($this->preventsLazyLoading) {

            $this->handleLazyLoadingViolation($key);

        }

        // If the "attribute" exists as a method on the model, we will just assume

        // it is a relationship and will load and return results from the query

        // and hydrate the relationship's value on the "relationships" array.

        return $this->getRelationshipFromMethod($key);

    }

    /**

     * Determine if the given key is a relationship method on the model.

     *

     * @param  string  $key

     * @return bool

     */

    public function isRelation($key)

    {

        if ($this->hasAttributeMutator($key)) {

            return false;

        }

        return method_exists($this, $key) ||

               $this->relationResolver(static::class, $key);

    }

    /**

     * Handle a lazy loading violation.

     *

     * @param  string  $key

     * @return mixed

     */

    protected function handleLazyLoadingViolation($key)

    {

        if (isset(static::$lazyLoadingViolationCallback)) {

            return call_user_func(static::$lazyLoadingViolationCallback, $this, $key);

        }

        if (! $this->exists || $this->wasRecentlyCreated) {

            return;

        }

        throw new LazyLoadingViolationException($this, $key);

    }

    /**

     * Get a relationship value from a method.

     *

     * @param  string  $method

     * @return mixed

     *

     * @throws \LogicException

     */

    protected function getRelationshipFromMethod($method)

    {

        $relation = $this->$method();

        if (! $relation instanceof Relation) {

            if (is_null($relation)) {

                throw new LogicException(sprintf(

                    '%s::%s must return a relationship instance, but "null" was returned. Was the "return" keyword used?', static::class, $method

                ));

            }

            throw new LogicException(sprintf(

                '%s::%s must return a relationship instance.', static::class, $method

            ));

        }

        return tap($relation->getResults(), function ($results) use ($method) {

            $this->setRelation($method, $results);

        });

    }

    /**

     * Determine if a get mutator exists for an attribute.

     *

     * @param  string  $key

     * @return bool

     */

    public function hasGetMutator($key)

    {

        return method_exists($this, 'get'.Str::studly($key).'Attribute');

    }

    /**

     * Determine if a "Attribute" return type marked mutator exists for an attribute.

     *

     * @param  string  $key

     * @return bool

     */

    public function hasAttributeMutator($key)

    {

        if (isset(static::$attributeMutatorCache[get_class($this)][$key])) {

            return static::$attributeMutatorCache[get_class($this)][$key];

        }

        if (! method_exists($this, $method = Str::camel($key))) {

            return static::$attributeMutatorCache[get_class($this)][$key] = false;

        }

        $returnType = (new ReflectionMethod($this, $method))->getReturnType();

        return static::$attributeMutatorCache[get_class($this)][$key] =

                    $returnType instanceof ReflectionNamedType &&

                    $returnType->getName() === Attribute::class;

    }

    /**

     * Determine if a "Attribute" return type marked get mutator exists for an attribute.

     *

     * @param  string  $key

     * @return bool

     */

    public function hasAttributeGetMutator($key)

    {

        if (isset(static::$getAttributeMutatorCache[get_class($this)][$key])) {

            return static::$getAttributeMutatorCache[get_class($this)][$key];

        }

        if (! $this->hasAttributeMutator($key)) {

            return static::$getAttributeMutatorCache[get_class($this)][$key] = false;

        }

        return static::$getAttributeMutatorCache[get_class($this)][$key] = is_callable($this->{Str::camel($key)}()->get);

    }

    /**

     * Get the value of an attribute using its mutator.

     *

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    protected function mutateAttribute($key, $value)

    {

        return $this->{'get'.Str::studly($key).'Attribute'}($value);

    }

    /**

     * Get the value of an "Attribute" return type marked attribute using its mutator.

     *

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    protected function mutateAttributeMarkedAttribute($key, $value)

    {

        if (array_key_exists($key, $this->attributeCastCache)) {

            return $this->attributeCastCache[$key];

        }

        $attribute = $this->{Str::camel($key)}();

        $value = call_user_func($attribute->get ?: function ($value) {

            return $value;

        }, $value, $this->attributes);

        if ($attribute->withCaching || (is_object($value) && $attribute->withObjectCaching)) {

            $this->attributeCastCache[$key] = $value;

        } else {

            unset($this->attributeCastCache[$key]);

        }

        return $value;

    }

    /**

     * Get the value of an attribute using its mutator for array conversion.

     *

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    protected function mutateAttributeForArray($key, $value)

    {

        if ($this->isClassCastable($key)) {

            $value = $this->getClassCastableAttributeValue($key, $value);

        } elseif (isset(static::$getAttributeMutatorCache[get_class($this)][$key]) &&

                  static::$getAttributeMutatorCache[get_class($this)][$key] === true) {

            $value = $this->mutateAttributeMarkedAttribute($key, $value);

            $value = $value instanceof DateTimeInterface

                        ? $this->serializeDate($value)

                        : $value;

        } else {

            $value = $this->mutateAttribute($key, $value);

        }

        return $value instanceof Arrayable ? $value->toArray() : $value;

    }

    /**

     * Merge new casts with existing casts on the model.

     *

     * @param  array  $casts

     * @return $this

     */

    public function mergeCasts($casts)

    {

        $this->casts = array_merge($this->casts, $casts);

        return $this;

    }

    /**

     * Cast an attribute to a native PHP type.

     *

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    protected function castAttribute($key, $value)

    {

        $castType = $this->getCastType($key);

        if (is_null($value) && in_array($castType, static::$primitiveCastTypes)) {

            return $value;

        }

        // If the key is one of the encrypted castable types, we'll first decrypt

        // the value and update the cast type so we may leverage the following

        // logic for casting this value to any additionally specified types.

        if ($this->isEncryptedCastable($key)) {

            $value = $this->fromEncryptedString($value);

            $castType = Str::after($castType, 'encrypted:');

        }

        switch ($castType) {

            case 'int':

            case 'integer':

                return (int) $value;

            case 'real':

            case 'float':

            case 'double':

                return $this->fromFloat($value);

            case 'decimal':

                return $this->asDecimal($value, explode(':', $this->getCasts()[$key], 2)[1]);

            case 'string':

                return (string) $value;

            case 'bool':

            case 'boolean':

                return (bool) $value;

            case 'object':

                return $this->fromJson($value, true);

            case 'array':

            case 'json':

                return $this->fromJson($value);

            case 'collection':

                return new BaseCollection($this->fromJson($value));

            case 'date':

                return $this->asDate($value);

            case 'datetime':

            case 'custom_datetime':

                return $this->asDateTime($value);

            case 'immutable_date':

                return $this->asDate($value)->toImmutable();

            case 'immutable_custom_datetime':

            case 'immutable_datetime':

                return $this->asDateTime($value)->toImmutable();

            case 'timestamp':

                return $this->asTimestamp($value);

        }

        if ($this->isEnumCastable($key)) {

            return $this->getEnumCastableAttributeValue($key, $value);

        }

        if ($this->isClassCastable($key)) {

            return $this->getClassCastableAttributeValue($key, $value);

        }

        return $value;

    }

    /**

     * Cast the given attribute using a custom cast class.

     *

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    protected function getClassCastableAttributeValue($key, $value)

    {

        if (isset($this->classCastCache[$key])) {

            return $this->classCastCache[$key];

        } else {

            $caster = $this->resolveCasterClass($key);

            $value = $caster instanceof CastsInboundAttributes

                ? $value

                : $caster->get($this, $key, $value, $this->attributes);

            if ($caster instanceof CastsInboundAttributes || ! is_object($value)) {

                unset($this->classCastCache[$key]);

            } else {

                $this->classCastCache[$key] = $value;

            }

            return $value;

        }

    }

    /**

     * Cast the given attribute to an enum.

     *

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    protected function getEnumCastableAttributeValue($key, $value)

    {

        if (is_null($value)) {

            return;

        }

        $castType = $this->getCasts()[$key];

        if ($value instanceof $castType) {

            return $value;

        }

        return $this->getEnumCaseFromValue($castType, $value);

    }

    /**

     * Get the type of cast for a model attribute.

     *

     * @param  string  $key

     * @return string

     */

    protected function getCastType($key)

    {

        $castType = $this->getCasts()[$key];

        if (isset(static::$castTypeCache[$castType])) {

            return static::$castTypeCache[$castType];

        }

        if ($this->isCustomDateTimeCast($castType)) {

            $convertedCastType = 'custom_datetime';

        } elseif ($this->isImmutableCustomDateTimeCast($castType)) {

            $convertedCastType = 'immutable_custom_datetime';

        } elseif ($this->isDecimalCast($castType)) {

            $convertedCastType = 'decimal';

        } else {

            $convertedCastType = trim(strtolower($castType));

        }

        return static::$castTypeCache[$castType] = $convertedCastType;

    }

    /**

     * Increment or decrement the given attribute using the custom cast class.

     *

     * @param  string  $method

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    protected function deviateClassCastableAttribute($method, $key, $value)

    {

        return $this->resolveCasterClass($key)->{$method}(

            $this, $key, $value, $this->attributes

        );

    }

    /**

     * Serialize the given attribute using the custom cast class.

     *

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    protected function serializeClassCastableAttribute($key, $value)

    {

        return $this->resolveCasterClass($key)->serialize(

            $this, $key, $value, $this->attributes

        );

    }

    /**

     * Determine if the cast type is a custom date time cast.

     *

     * @param  string  $cast

     * @return bool

     */

    protected function isCustomDateTimeCast($cast)

    {

        return str_starts_with($cast, 'date:') ||

                str_starts_with($cast, 'datetime:');

    }

    /**

     * Determine if the cast type is an immutable custom date time cast.

     *

     * @param  string  $cast

     * @return bool

     */

    protected function isImmutableCustomDateTimeCast($cast)

    {

        return str_starts_with($cast, 'immutable_date:') ||

                str_starts_with($cast, 'immutable_datetime:');

    }

    /**

     * Determine if the cast type is a decimal cast.

     *

     * @param  string  $cast

     * @return bool

     */

    protected function isDecimalCast($cast)

    {

        return str_starts_with($cast, 'decimal:');

    }

    /**

     * Set a given attribute on the model.

     *

     * @param  string  $key

     * @param  mixed  $value

     * @return mixed

     */

    public function setAttribute($key, $value)

    {

        // First we will check for the presence of a mutator for the set operation

        // which simply lets the developers tweak the attribute as it is set on

        // this model, such as "json_encoding" a listing of data for storage.

        if ($this->hasSetMutator($key)) {

            return $this->setMutatedAttributeValue($key, $value);

        } elseif ($this->hasAttributeSetMutator($key)) {

            return $this->setAttributeMarkedMutatedAttributeValue($key, $value);

        }

        // If an attribute is listed as a "date", we'll convert it from a DateTime

        // instance into a form proper for storage on the database tables using

        // the connection grammar's date format. We will auto set the values.

        elseif (! is_null($value) && $this->isDateAttribute($key)) {

            $value = $this->fromDateTime($value);

        }

        if ($this->isEnumCastable($key)) {

            $this->setEnumCastableAttribute($key, $value);

            return $this;

        }

        if ($this->isClassCastable($key)) {

            $this->setClassCastableAttribute($key, $value);

            return $this;

        }

        if (! is_null($value) && $this->isJsonCastable($key)) {

            $value = $this->castAttributeAsJson($key, $value);

        }

        // If this attribute contains a JSON ->, we'll set the proper value in the

        // attribute's underlying array. This takes care of properly nesting an

        // attribute in the array's value in the case of deeply nested items.

        if (str_contains($key, '->')) {

            return $this->fillJsonAttribute($key, $value);

        }

        if (! is_null($value) && $this->isEncryptedCastable($key)) {

            $value = $this->castAttributeAsEncryptedString($key, $value);

        }

        $this->attributes[$key] = $value;

        return $this;

    }

    /**

     * Determine if a set mutator exists for an attribute.

     *

     * @param  string  $key

     * @return bool