Final Class Yiisoft\Queue\Queue

                public function __clone()
{
    $finalPushHandler = $this->createFinalPushHandler();
    $this->baseDispatcher = $this->baseDispatcher->withFinishHandler($finalPushHandler);
    $this->dispatcher = $this->dispatcher->withFinishHandler($finalPushHandler);
}

            

                public function __construct(
    private readonly WorkerInterface $worker,
    private readonly LoopInterface $loop,
    private readonly LoggerInterface $logger,
    PushMiddlewareConfig $middlewareConfig,
    private readonly ?AdapterInterface $adapter = null,
    string|BackedEnum $name = QueueProviderInterface::DEFAULT_QUEUE,
    mixed ...$middlewareDefinitions,
) {
    $this->name = StringNormalizer::normalize($name);
    $this->baseDispatcher = new PushMiddlewareDispatcher(
        $middlewareConfig->middlewareFactory,
        $middlewareConfig->commonMiddlewareDefinitions,
        $this->createFinalPushHandler(),
    );
    $this->setMiddlewaresAndPrepareDispatcher($middlewareDefinitions);
}

            

                public function getName(): string
{
    return $this->name;
}

            

                public function listen(): void
{
    if ($this->isSynchronous()) {
        $this->logger->info('Cannot listen without an adapter. Queue is in synchronous mode.');
        return;
    }
    $this->logger->info('Start listening to the queue.');
    $this->adapter->subscribe(fn(MessageInterface $message) => $this->handle($message));
    $this->logger->info('Finish listening to the queue.');
}

            

                public function push(MessageInterface $message): MessageInterface
{
    $this->logger->debug(
        'Preparing to push message with message type "{messageType}".',
        ['messageType' => $message->getType()],
    );
    $message = $this->dispatcher->dispatch($message);
    if ($this->isSynchronous()) {
        $this->logger->info(
            'Processed message with message type "{messageType}" synchronously.',
            ['messageType' => $message->getType()],
        );
        return $message;
    }
    $messageId = IdEnvelope::fromMessage($message)->getId();
    if ($messageId === null) {
        $this->logger->info(
            'Pushed message with message type "{messageType}" to the queue. ID doesn\'t assigned.',
            ['messageType' => $message->getType()],
        );
    } else {
        $this->logger->info(
            'Pushed message with message type "{messageType}" to the queue. Assigned ID #{id}.',
            ['messageType' => $message->getType(), 'id' => $messageId],
        );
    }
    return $message;
}

            

                public function run(int $max = 0): int
{
    if ($this->isSynchronous()) {
        $this->logger->debug(
            'Queue is in synchronous mode (no adapter). Messages are processed on push. run() does nothing.',
        );
        return 0;
    }
    $this->logger->debug('Start processing queue messages.');
    $count = 0;
    $handlerCallback = function (MessageInterface $message) use (&$max, &$count): bool {
        if (($max > 0 && $max <= $count) || !$this->handle($message)) {
            return false;
        }
        $count++;
        return true;
    };
    $this->adapter->runExisting($handlerCallback);
    $this->logger->info(
        'Processed {count} queue messages.',
        ['count' => $count],
    );
    return $count;
}

            

                public function status(string|int $id): MessageStatus
{
    if ($this->isSynchronous()) {
        return MessageStatus::NOT_FOUND;
    }
    return $this->adapter->status($id);
}

            

                public function withMiddlewares(mixed ...$middlewareDefinitions): self
{
    $instance = clone $this;
    $instance->setMiddlewaresAndPrepareDispatcher($middlewareDefinitions);
    return $instance;
}

            

                public function withMiddlewaresAdded(mixed ...$middlewareDefinitions): self
{
    $instance = clone $this;
    $instance->setMiddlewaresAndPrepareDispatcher([...array_values($instance->middlewareDefinitions), ...array_values($middlewareDefinitions)]);
    return $instance;
}