class Model extends Eloquent
{
    protected $table = 'models';

    protected $casts = [
        'options' => CustomCast::class
    ];

    .....
}

$model = Model::find(1);

$model->options->get('value');   // <-- get called
$model->options->get('value');   // <-- set called
$model->options->get('value');   // <-- set called
$model->options->get('value');   // <-- set called

$model->save();     // <-- for some reason set is executed 4 times here

// no cast
$var = $model->number; // = 2
$var = 5;
echo $model->number; // 2

// custom cast (for example a carbon object)
$var = $model->custom; // = 2020-06-01
$var->addDays(7);
echo $model->custom; // 2020-06-08 instead of 2020-06-01

class CollectionCast implements CastsAttributes
{
    public function get($model, string $key, $value, array $attributes)
    {
        return new Collection(json_decode($value, true));
    }
    
    public function set($model, string $key, $value, array $attributes)
    {
        if ($value instanceof Collection) {
            $value = $value->toArray();
        }

        return json_encode($value);
    }
}

class Model extends Eloquent
{
    protected $table = 'models';

    protected $casts = [
        'options' => CollectionCast::class
    ];
}

class ModelOptimized extends Eloquent
{
    use CustomCastsOptimizer;

    protected $table = 'models';

    protected $casts = [
        'options' => CollectionCast::class
    ];
}

Debugbar::measure('un-optimized', function () {
    $model = Model::find(1);

    for ($i = 0; $i < 10; $i++) {
        $model->options->get(10);
        $model->options->get(20);
        $model->options->put('test', 100);
        // $model->options->put('test', $i);   // test for changing custom cast value

        $model->save();
    }
});

Debugbar::measure('optimized', function () {
    $model = ModelOptimized::find(1);

    for ($i = 0; $i < 10; $i++) {
        $model->options->get(10);
        $model->options->get(20);
        $model->options->put('test', 100);
        // $model->options->put('test', $i);  // test for changing custom cast value

        $model->save();
    }
});

<?php

namespace App\Foundation\Database\Eloquent\Traits;

use Illuminate\Contracts\Database\Eloquent\CastsInboundAttributes;
use Illuminate\Database\Eloquent\Builder;

trait CustomCastsOptimizer
{
    /**
     * Determine if the model or any of the given attribute(s) have been modified.
     *
     * @param  array|string|null  $attributes
     * @return bool
     */
    public function isDirty($attributes = null)
    {
        $attributes = is_array($attributes) ? $attributes : func_get_args();

        foreach ($attributes ?: array_keys($this->attributes) as $key) {
            if (! array_key_exists($key, $this->attributes)) {
                continue;
            }

            $this->mergeAttributeFromClassCasts($key);

            if (! $this->originalIsEquivalent($key)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Get an attribute from the model.
     *
     * @param  string  $key
     * @return mixed
     */
    public function getAttribute($key)
    {
        if (! $key) {
            return;
        }

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

        return parent::getAttribute($key);
    }

    /**
     * Get an attribute from the $attributes array.
     *
     * @param  string  $key
     * @return mixed
     */
    protected function getAttributeFromArray($key)
    {
        $this->mergeAttributeFromClassCasts($key);

        return $this->attributes[$key] ?? null;
    }

    /**
     * Sync multiple original attribute with their current values.
     *
     * @param  array|string  $attributes
     * @return $this
     */
    public function syncOriginalAttributes($attributes)
    {
        $attributes = is_array($attributes) ? $attributes : func_get_args();

        foreach ($attributes as $attribute) {
            $this->original[$attribute] = $this->getAttributeFromArray($attribute);
        }

        return $this;
    }

    /**
     * Merge a single cast class attribute back into the model.
     *
     * @param  string  $key
     * @return void
     */
    protected function mergeAttributeFromClassCasts($key)
    {
        if (! isset($this->classCastCache[$key])) {
            return;
        }

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

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

        $this->attributes = array_merge(
            $this->attributes,
            $caster instanceof CastsInboundAttributes
                ? [$key => $value]
                : $this->normalizeCastClassResponse($key, $caster->set($this, $key, $value, $this->attributes))
        );
    }

    /**
     * Merge the cast class attributes back into the model.
     *
     * @return void
     */
    protected function mergeAttributesFromClassCasts()
    {
        foreach ($this->classCastCache as $key => $value) {
            $this->mergeAttributeFromClassCasts($key);
        }
    }

    /**
     * Perform a model update operation.
     *
     * @param  \Illuminate\Database\Eloquent\Builder  $query
     * @return bool
     */
    protected function performUpdate(Builder $query)
    {
        // Once we have run the update operation, we will fire the "updated" event for
        // this model instance. This will allow developers to hook into these after
        // models are updated, giving them a chance to do any special processing.
        $changes = $this->getDirty();

        if ($changes) {
            // If the updating event returns false, we will cancel the update operation so
            // developers can hook Validation systems into their models and cancel this
            // operation if the model does not pass validation. Otherwise, we update.
            if ($this->fireModelEvent('updating') === false) {
                return false;
            }

            // First we need to create a fresh query instance and touch the creation and
            // update timestamp on the model which are maintained by us for developer
            // convenience. Then we will just continue saving the model instances.
            if ($this->usesTimestamps()) {
                $this->updateTimestamps();
            }

            $this->setKeysForSaveQuery($query)->update($changes);

            $this->changes = $changes;

            $this->fireModelEvent('updated', false);
        }

        return true;
    }

    /**
     * Save the model to the database.
     *
     * @param  array  $options
     * @return bool
     */
    public function save(array $options = [])
    {
        $query = $this->newModelQuery();

        // If the "saving" event returns false we'll bail out of the save and return
        // false, indicating that the save failed. This provides a chance for any
        // listeners to cancel save operations if validations fail or whatever.
        if ($this->fireModelEvent('saving') === false) {
            return false;
        }

        // If the model already exists in the database we can just update our record
        // that is already in this database using the current IDs in this "where"
        // clause to only update this model. Otherwise, we'll just insert them.
        if ($this->exists) {
            $saved = $this->performUpdate($query);
        }

        // If the model is brand new, we'll insert it into our database and set the
        // ID attribute on the model to the value of the newly inserted row's ID
        // which is typically an auto-increment value managed by the database.
        else {
            $saved = $this->performInsert($query);

            if (! $this->getConnectionName() &&
                $connection = $query->getConnection()) {
                $this->setConnection($connection->getName());
            }
        }

        // If the model is successfully saved, we need to do a few more things once
        // that is done. We will call the "saved" method here to run any actions
        // we need to happen after a model gets successfully saved right here.
        if ($saved) {
            $this->finishSave($options);
        }

        return $saved;
    }

    /**
     * Perform any actions that are necessary after the model is saved.
     *
     * @param  array  $options
     * @return void
     */
    protected function finishSave(array $options)
    {
        $this->fireModelEvent('saved', false);

        $wasChanged = ($this->wasRecentlyCreated && empty($this->original)) || $this->changes;

        if ($wasChanged && ($options['touch'] ?? true)) {
            $this->touchOwners();
        }

        $this->original = $this->attributes;
    }
}

abstract class Model extends BaseModel
{
    use CustomCastsOptimizer;
    
    ```

protected function addCastAttributesToArray(array $attributes, array $mutatedAttributes)
{
  $attributes = parent::addCastAttributesToArray($attributes, $mutatedAttributes);

  foreach (\array_diff_key($attributes, $this->getCasts(), $mutatedAttributes) as $attribute => $value) {
    $attributes[$attribute] = $this->a->{$attribute}; // here it would need a bit of logic to cast objects to string, int or array
  }

  return $attributes;
}

$this->getEventDispatcher()->hasListeners('eloquent.updating: ' . $this::class)

$this->getEventDispatcher()->hasListeners($this::class . '.updating')