finish example

            while ($offset < $totalResultCount) {
                $sliceUrls = \array_slice($urls, $offset, $limit, true);
                $cacheWarmer->warmUpUrls($sliceUrls, $context, $concurrentRequests);

                $sliceCount = \count($sliceUrls);
                if ($sliceCount === 0) {
                    break;
                }
                $progressBar->advance($sliceCount);
                $offset += $sliceCount;
            }
            $progressBar->finish();
            $io->newLine();
        }
        $io->newLine();
        $io->success('The HttpCache is now warmed up');

        return 0;
    }

    /** * Builds an array using input parameters, which is used to know what to warm up * * @return array */

$progress = $this->IOHelper->createProgressBar($totalCount);
        $progress->setRedrawFrequency(20);
        $progress->start();

        foreach ($dump as $sql) {
            // Execute each query one by one             // https://bugs.php.net/bug.php?id=61613             $conn->exec($sql);
            $progress->advance();
        }
        $progress->finish();
        $this->IOHelper->writeln('');
    }

    private function askShopwareEdition(
        Shop $shop,
        LicenseUnpackService $licenseService,
        LicenseInstaller $licenseInstaller
    ) {
        $shopwareEdition = $this->askEdition();
        if (!$shopwareEdition->isCommercial()) {
            return;
        }

foreach ($paginator as $media) {
            try {
                $this->createMediaThumbnails($media);
            } catch (Exception $e) {
                $this->errors[] = $e->getMessage();
            }

            $progressBar->advance();
        }

        $progressBar->finish();

        // Force newline when processing the next album         $this->output->writeln('');
    }

    /** * Check each single thumbnail to skip already existing thumbnails * * @throws Exception */
    private function createMediaThumbnails(Media $media)
    {

/* Recalculate the Poly1305 authentication tag (MAC): */
        $state = new ParagonIE_Sodium_Core32_Poly1305_State($block0);
        try {
            ParagonIE_Sodium_Compat::memzero($block0);
        } catch (SodiumException $ex) {
            $block0 = null;
        }
        $state->update($ad);
        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($adlen));
        $state->update($ciphertext);
        $state->update(ParagonIE_Sodium_Core32_Util::store64_le($clen));
        $computed_mac = $state->finish();

        /* Compare the given MAC with the recalculated MAC: */
        if (!ParagonIE_Sodium_Core32_Util::verify_16($computed_mac, $mac)) {
            throw new SodiumException('Invalid MAC');
        }

        // Here, we know that the MAC is valid, so we decrypt and return the plaintext         return ParagonIE_Sodium_Core32_ChaCha20::streamXorIc(
            $ciphertext,
            $nonce,
            $key,
            

$output->writeln("\rCounted {$count} items");

        $progressHelper = new ProgressBar($output, $count);
        $progressHelper->setFormat(' %current%/%max% [%bar%] %percent%% Elapsed: %elapsed%');

        // create the assignments         while ($progress < $count) {
            $component->rebuildAllAssignments($limit, $progress);
            $progress += $limit;
            $progressHelper->advance();
        }
        $progressHelper->finish();

        $output->writeln("\nDone");

        return 0;
    }
}

$queue->addInsert('cart', $value);

            if ($index % 50 === 0) {
                $queue->execute();
            }

            $this->progress->advance();
        }

        $queue->execute();

        $this->progress->finish();

        $this->io->success('Migration from Redis to SQL was successful');

        $this->io->newLine(2);

        return self::SUCCESS;
    }

    private function sqlToRedis(InputInterface $input, OutputInterface $output): int
    {
        if ($this->redis === null) {
            

$this->removeDirectory($adminDir . '/Resources/app/administration/src/scripts');
        $this->removeDirectory($adminDir . '/Resources/app/administration/patches');
        unlink($adminDir . '/Resources/app/administration/package-lock.json');
        $progressBar->advance(25);

        $this->removeDirectory($adminDir . '/Resources/app/administration/static');
        $this->removeDirectory($adminDir . '/Resources/app/administration/build');
        $this->removeDirectory($adminDir . '/Resources/app/administration/scripts');
        $this->removeDirectory($adminDir . '/Resources/app/administration/eslint-rules');
        $this->removeDirectory($adminDir . '/Resources/app/administration/test');
        $progressBar->advance(25);
        $progressBar->finish();

        $output->writeln('');
        $output->writeln('All unnecessary files of the administration after the build process have been deleted.');

        return 0;
    }

    private function deleteEmptyDirectories(string $dir): void
    {
        if (!is_dir($dir)) {
            return;
        }

  public function execute() {
    return $this
      ->prepare()
      ->addAggregate()
      ->compile()
      ->compileAggregate()
      ->addGroupBy()
      ->addSort()
      ->addSortAggregate()
      ->finish()
      ->result();
  }

  /** * {@inheritdoc} */
  public function prepare() {
    parent::prepare();
    // Throw away the id fields.     $this->sqlFields = [];
    return $this;
  }

public function __invoke(RequestInterface $request, array $options): PromiseInterface
    {
        if (isset($options['delay'])) {
            \usleep($options['delay'] * 1000);
        }

        $easy = $this->factory->create($request, $options);
        \curl_exec($easy->handle);
        $easy->errno = \curl_errno($easy->handle);

        return CurlFactory::finish($this, $easy, $this->factory);
    }
}

$this->connection = $connection;
  }

  /** * {@inheritdoc} */
  public function execute() {
    return $this
      ->prepare()
      ->compile()
      ->addSort()
      ->finish()
      ->result();
  }

  /** * Prepares the basic query with proper metadata/tags and base fields. * * @return $this * Returns the called object. * * @throws \Drupal\Core\Entity\Query\QueryException * Thrown if the base table does not exist. */

$insert->execute([
                        ':streamId' => $streamId,
                        ':customerId' => $customerId,
                    ]);
                }

                $helper->advance((int) $criteria->getLimit());
                $criteria->offset($criteria->getOffset() + $criteria->getLimit());
                $customers = $this->numberSearch->search($criteria);
            }

            $helper->finish();
        });
    }

    /** * @param int $streamId * * @return CustomerNumberSearchResult */
    public function populatePartial($streamId, Criteria $criteria)
    {
        $result = $this->numberSearch->search($criteria);

        

$step = $this->count - $this->current;
        }
        $this->progress->advance($step);
        $this->current += $step;
    }

    /** * {@inheritdoc} */
    public function finish()
    {
        $this->progress->finish();
        $this->output->writeln('');
    }
}

\curl_multi_remove_handle($this->_mh, $done['handle']);

            if (!isset($this->handles[$id])) {
                // Probably was cancelled.                 continue;
            }

            $entry = $this->handles[$id];
            unset($this->handles[$id], $this->delays[$id]);
            $entry['easy']->errno = $done['result'];
            $entry['deferred']->resolve(
                CurlFactory::finish($this, $entry['easy'], $this->factory)
            );
        }
    }

    private function timeToNext(): int
    {
        $currentTime = Utils::currentTime();
        $nextTime = \PHP_INT_MAX;
        foreach ($this->delays as $time) {
            if ($time < $nextTime) {
                $nextTime = $time;
            }

$filesToMigrate = 0;

        if (!$skipScan) {
            $filesToMigrate = $this->countFilesToMigrate('media', $fromFilesystem);
        }

        $progressBar = new ProgressBar($output, $filesToMigrate);
        $progressBar->setFormat(" %current%/%max% [%bar%] %percent%%, %migrated% migrated, %skipped% skipped, %moved% moved, Elapsed: %elapsed%\n Current file: %filename%");
        $progressBar->setMessage('', 'filename');
        $this->migrateFilesIn('media', $fromFilesystem, $toFileSystem, $progressBar);
        $progressBar->finish();

        $rows = [];
        foreach ($this->counter as $key => $value) {
            $rows[] = [$key, $value];
        }

        $output->writeln('');
        $output->writeln('');

        $table = new Table($output);
        $table->setStyle('borderless');
        

    public function progressAdvance(int $step = 1)
    {
        $this->getProgressBar()->advance($step);
    }

    /** * @return void */
    public function progressFinish()
    {
        $this->getProgressBar()->finish();
        $this->newLine(2);
        unset($this->progressBar);
    }

    public function createProgressBar(int $max = 0): ProgressBar
    {
        $progressBar = parent::createProgressBar($max);

        if ('\\' !== \DIRECTORY_SEPARATOR || 'Hyper' === getenv('TERM_PROGRAM')) {
            $progressBar->setEmptyBarCharacter('░'); // light shade character \u2591             $progressBar->setProgressCharacter('');