CodeExplorer

__sleep example

    $filters = $filter_format->get('filters');
    $this->assertFalse(isset($filters['filter_test_restrict_tags_and_attributes']), 'The filter plugin filter_test_restrict_tags_and_attributes is not configured by the filtered_html filter format.');
  }

  /** * Tests that format entities are serialized without their plugin collection. */
  public function testSleep() {
    $filter_format = FilterFormat::load('filtered_html');

    $this->assertNull($filter_format->get('filterCollection'));
    $vars = $filter_format->__sleep();
    $this->assertContains('filters', $vars);
    $this->assertNotContains('filterCollection', $vars);
  }

}

$entity->setPluginManager($plugin_manager->reveal());

    // After creating the entity, change the plugin configuration.     $instance->setConfiguration(['foo' => 'new_value']);

    // After changing the plugin configuration, the entity still has the     // original value.     $expected_plugin_config = [$instance_id => ['foo' => 'original_value']];
    $this->assertSame($expected_plugin_config, $entity->get('the_plugin_collection_config'));

    // Ensure the plugin collection and manager is not stored.     $vars = $entity->__sleep();
    $this->assertNotContains('pluginCollection', $vars);
    $this->assertNotContains('pluginManager', $vars);
    $this->assertSame(['pluginManager' => 'plugin.manager.foo'], $entity->get('_serviceIds'));

    $expected_plugin_config = [$instance_id => ['foo' => 'new_value']];
    // Ensure the updated values are stored in the entity.     $this->assertSame($expected_plugin_config, $entity->get('the_plugin_collection_config'));
  }

  /** * @covers ::setOriginalId * @covers ::getOriginalId */

public function addConstraint(Constraint $constraint): static
    {
        $this->checkConstraint($constraint);

        parent::addConstraint($constraint);

        return $this;
    }

    public function __sleep(): array
    {
        return array_merge(parent::__sleep(), [
            'class',
            'name',
            'property',
        ]);
    }

    /** * Returns the name of the member. */
    public function getName(): string
    {

    // not depend on knowing that the Locale module exists.     if (function_exists('locale_get_plural') && \Drupal::hasService('locale.plural.formula')) {
      return locale_get_plural($this->count, $this->getOption('langcode'));
    }
    return -1;
  }

  /** * {@inheritdoc} */
  public function __sleep() {
    return array_merge(parent::__sleep(), ['count']);
  }

}

$table_definition = \Drupal::service('views.views_data')->get($this->base_table);
    // Check whether the base table definition exists and contains a base table     // definition. For example, taxonomy_views_data_alter() defines     // node_field_data even if it doesn't exist as a base table.     return $table_definition && isset($table_definition['table']['base']);
  }

  /** * {@inheritdoc} */
  public function __sleep() {
    $keys = parent::__sleep();
    unset($keys[array_search('executable', $keys)]);
    return $keys;
  }

  /** * Invalidates cache tags. */
  public function invalidateCaches() {
    // Invalidate cache tags for cached rows.     $tags = $this->getCacheTags();
    \Drupal::service('cache_tags.invalidator')->invalidateTags($tags);
  }

return FALSE;
        }
      }
    }
    return TRUE;
  }

  /** * {@inheritdoc} */
  public function __sleep() {
    return array_diff(parent::__sleep(), ['database']);
  }

}

        if ($this->clonesCount !== $this->clonesIndex) {
            return [];
        }

        $this->data[] = $this->fileLinkFormat;
        $this->data[] = $this->charset;
        $this->dataCount = 0;
        $this->isCollected = true;

        return parent::__sleep();
    }

    /** * @internal */
    public function __wakeup()
    {
        parent::__wakeup();

        $charset = array_pop($this->data);
        $fileLinkFormat = array_pop($this->data);

$properties["\0$class\0lazyObjectReal"] = $state->realInstance ??= ($state->initializer)();
            }
        }

        if ($state || Registry::$parentMethods[$class]['serialize'] || !Registry::$parentMethods[$class]['sleep']) {
            return $properties;
        }

        $scope = get_parent_class($class);
        $data = [];

        foreach (parent::__sleep() as $name) {
            $value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;

            if (null === $k) {
                trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
            } else {
                $data[$k] = $value;
            }
        }

        return $data;
    }

public static function loadByName($entity_type_id, $bundle, $field_name) {
    return \Drupal::entityTypeManager()->getStorage('base_field_override')->load($entity_type_id . '.' . $bundle . '.' . $field_name);
  }

  /** * Implements the magic __sleep() method. */
  public function __sleep() {
    // Only serialize necessary properties, excluding those that can be     // recalculated.     unset($this->baseFieldDefinition);
    return parent::__sleep();
  }

}

  protected function reInjectMe() {
    // When rebuilding the container,     // \Drupal\Core\DrupalKernel::initializeContainer() saves the hashes of the     // old container and passes them to the new one. So __sleep() will     // recognize the old services and then __wakeup() will restore them from     // the new container.     $this->__sleep();
    $this->__wakeup();
  }

}

$this->name = $class;
        // class name without namespace         if (false !== $nsSep = strrpos($class, '\\')) {
            $this->defaultGroup = substr($class, $nsSep + 1);
        } else {
            $this->defaultGroup = $class;
        }
    }

    public function __sleep(): array
    {
        $parentProperties = parent::__sleep();

        // Don't store the cascading strategy. Classes never cascade.         unset($parentProperties[array_search('cascadingStrategy', $parentProperties)]);

        return array_merge($parentProperties, [
            'getters',
            'groupSequence',
            'groupSequenceProvider',
            'members',
            'name',
            'properties',

else {
      $this->vocabularyHierarchyType[$vid] = VocabularyInterface::HIERARCHY_MULTIPLE;
    }

    return $this->vocabularyHierarchyType[$vid];
  }

  /** * {@inheritdoc} */
  public function __sleep() {
    $vars = parent::__sleep();
    // Do not serialize static cache.     unset($vars['ancestors'], $vars['treeChildren'], $vars['treeParents'], $vars['treeTerms'], $vars['trees'], $vars['vocabularyHierarchyType']);
    return $vars;
  }

  /** * {@inheritdoc} */
  public function __wakeup() {
    parent::__wakeup();
    // Initialize static caches.

$arrayValue = (array) $value;
            } elseif ($value instanceof \Serializable
                || $value instanceof \__PHP_Incomplete_Class
                || \PHP_VERSION_ID < 80200 && $value instanceof \DatePeriod
            ) {
                ++$objectsCount;
                $objectsPool[$value] = [$id = \count($objectsPool), serialize($value), [], 0];
                $value = new Reference($id);
                goto handle_value;
            } else {
                if (method_exists($class, '__sleep')) {
                    if (!\is_array($sleep = $value->__sleep())) {
                        trigger_error('serialize(): __sleep should return an array only containing the names of instance-variables to serialize', \E_USER_NOTICE);
                        $value = null;
                        goto handle_value;
                    }
                    $sleep = array_flip($sleep);
                }

                $arrayValue = (array) $value;
            }

            $proto = (array) $proto;