CodeExplorer

__destruct example

        }
    }

    public function __destruct()
    {
        if (isset($this->lazyObjectState)) {
            return;
        }

        if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
            parent::__destruct();
        }
    }
}

return $pdo;
  }

  /** * {@inheritdoc} */
  public function __destruct() {
    if ($this->needsCleanup) {
      $this->nextIdDelete();
    }
    parent::__destruct();
  }

  public function queryRange($query, $from, $count, array $args = [], array $options = []) {
    return $this->query($query . ' LIMIT ' . (int) $from . ', ' . (int) $count, $args, $options);
  }

  /** * {@inheritdoc} */
  public function queryTemporary($query, array $args = [], array $options = []) {
    $tablename = 'db_temporary_' . uniqid();

    public function __destruct()
    {
        $state = $this->lazyObjectState ?? null;

        if ($state && \in_array($state->status, [LazyObjectState::STATUS_UNINITIALIZED_FULL, LazyObjectState::STATUS_UNINITIALIZED_PARTIAL], true)) {
            return;
        }

        if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
            parent::__destruct();
        }
    }

    private function setLazyObjectAsInitialized(bool $initialized): void
    {
        $state = $this->lazyObjectState ?? null;

        if ($state && !\is_array($state->initializer)) {
            $state->status = $initialized ? LazyObjectState::STATUS_INITIALIZED_FULL : LazyObjectState::STATUS_UNINITIALIZED_FULL;
        }
    }
}

$this->definition->addTag($name, $attribute);
            }
        }
        $this->defaultTags = [];
    }

    /** * Registers a service. */
    final public function set(?string $id, string $class = null): ServiceConfigurator
    {
        $this->__destruct();

        return $this->parent->set($id, $class);
    }

    /** * Creates an alias. */
    final public function alias(string $id, string $referencedId): AliasConfigurator
    {
        $this->__destruct();

serialize($collector);
    }

    public function testFlush()
    {
        $data = new Data([[456]]);
        $collector = new DumpDataCollector();
        $collector->dump($data);
        $line = __LINE__ - 1;

        ob_start();
        $collector->__destruct();
        $output = preg_replace("/\033\[[^m]*m/", '', ob_get_clean());
        $this->assertSame("DumpDataCollectorTest.php on line {$line}:\n456\n", $output);
    }

    public function testFlushNothingWhenDataDumperIsProvided()
    {
        $data = new Data([[456]]);
        $dumper = new CliDumper('php://output');
        $collector = new DumpDataCollector(null, null, null, null, $dumper);

        ob_start();

$items = (int) $args['items'];
    if ( $items < 1 || 20 < $items ) {
        $items = 10;
    }
    $show_summary = (int) $args['show_summary'];
    $show_author  = (int) $args['show_author'];
    $show_date    = (int) $args['show_date'];

    if ( ! $rss->get_item_quantity() ) {
        echo '<ul><li>' . __( 'An error has occurred, which probably means the feed is down. Try again later.' ) . '</li></ul>';
        $rss->__destruct();
        unset( $rss );
        return;
    }

    echo '<ul>';
    foreach ( $rss->get_items( 0, $items ) as $item ) {
        $link = $item->get_link();
        while ( ! empty( $link ) && stristr( $link, 'http' ) !== $link ) {
            $link = substr( $link, 1 );
        }
        $link = esc_url( strip_tags( $link ) );

new NotNull(),
        ]);
        $this->expectValidateValueAt(1, 'k2', 'ccc', [
            new DateTime(),
        ]);

        $this->validator->validate('ccc', $this->constraint);

        $contextualValidator = $this->context->getValidator()->inContext($this->context);
        // Simulate __destruct to assert it throws         try {
            $contextualValidator->__destruct();
            $this->fail();
        } catch (ExpectationFailedException $e) {
        }

        // Actually fulfill expectations so real __destruct doesn't throw         $contextualValidator
            ->atPath('k2')
            ->validate('ccc', [
                new DateTime(),
            ]);
    }
}

/** * @return void */
    public function __wakeup()
    {
        throw new \BadMethodCallException('Cannot unserialize '.__CLASS__);
    }

    public function __destruct()
    {
        if (method_exists(parent::class, '__destruct')) {
            parent::__destruct();
        }
        if (isset($this->tmpSuffix) && is_file($this->directory.$this->tmpSuffix)) {
            unlink($this->directory.$this->tmpSuffix);
        }
    }
}

parent::__construct($parent, $definition, $id, $defaultTags);
    }

    public function __destruct()
    {
        if ($this->destructed) {
            return;
        }
        $this->destructed = true;

        parent::__destruct();

        $this->container->removeBindings($this->id);
        $this->container->setDefinition($this->id, $this->definition->setInstanceofConditionals($this->instanceof));
    }
}

$this->loader = $loader;
        $this->resource = $resource;
        $this->allowParent = $allowParent;
        $this->path = $path;

        parent::__construct($parent, $definition, $namespace, $defaults->getTags());
    }

    public function __destruct()
    {
        parent::__destruct();

        if (isset($this->loader)) {
            $this->loader->registerClasses($this->definition, $this->id, $this->resource, $this->excludes, $this->path);
        }
        unset($this->loader);
    }

    /** * Excludes files from registration using glob patterns. * * @param string[]|string $excludes * * @return $this */

/** * Remove items that link back to this before destroying this object */
    public function __destruct()
    {
        if (!gc_enabled())
        {
            if (!empty($this->data['items']))
            {
                foreach ($this->data['items'] as $item)
                {
                    $item->__destruct();
                }
                unset($item, $this->data['items']);
            }
            if (!empty($this->data['ordered_items']))
            {
                foreach ($this->data['ordered_items'] as $item)
                {
                    $item->__destruct();
                }
                unset($item, $this->data['ordered_items']);
            }
        }