PHP Table::addRows方法代码示例

 public function write(Table $table, UuidInterface $uuid)
 {
     $table->addRows(array(array('encode:', 'STR:', (string) $uuid), array('', 'INT:', (string) $uuid->getInteger())));
     if ($uuid->getVariant() == Uuid::RFC_4122) {
         $table->addRows(array(array('decode:', 'variant:', $this->getFormattedVariant($uuid)), array('', 'version:', $this->getFormattedVersion($uuid))));
         $table->addRows($this->getContent($uuid));
     } else {
         $table->addRows(array(array('decode:', 'variant:', 'Not an RFC 4122 UUID')));
     }
 }

 private function showDown(PokerGame $pokerGame)
 {
     $pokerGame->scoreHand();
     $table = new Table($this->output);
     foreach ($pokerGame->pokerPlayers as $player) {
         $finalHand = $player->showBestHand();
         $table->addRows([$finalHand]);
     }
     $finalHand = $pokerGame->hero->showBestHand();
     $table->addRows([$finalHand]);
     $table->render($this->output);
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $this->validateInput($input);
     $environment = $this->getSelectedEnvironment();
     $limit = (int) $input->getOption('limit');
     $activities = $environment->getActivities($limit, $input->getOption('type'));
     if (!$activities) {
         $this->stdErr->writeln('No activities found');
         return 1;
     }
     $headers = array("ID", "Created", "Description", "% Complete", "Result");
     $rows = array();
     foreach ($activities as $activity) {
         $description = $activity->getDescription();
         $description = wordwrap($description, 40);
         $rows[] = array($activity['id'], date('Y-m-d H:i:s', strtotime($activity['created_at'])), $description, $activity->getCompletionPercent(), $activity->state);
     }
     if ($output instanceof StreamOutput && ($input->getOption('pipe') || !$this->isTerminal($output))) {
         $stream = $output->getStream();
         array_unshift($rows, $headers);
         foreach ($rows as $row) {
             fputcsv($stream, $row, "\t");
         }
         return 0;
     }
     $this->stdErr->writeln("Recent activities for the environment <info>" . $environment['id'] . "</info>");
     $table = new Table($output);
     $table->setHeaders($headers);
     $table->addRows($rows);
     $table->render();
     return 0;
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $projectName = $input->getOption('project_name');
     $serviceName = $input->getOption('service_name');
     $em = $this->get('entity_manager');
     /*
      * Get Entities
      */
     $projectRepository = $em->getRepository('Mindgruve\\Gruver\\Entity\\Project');
     $serviceRepository = $em->getRepository('Mindgruve\\Gruver\\Entity\\Service');
     $releaseRepository = $em->getRepository('Mindgruve\\Gruver\\Entity\\Release');
     $project = $projectRepository->loadProjectByName($projectName);
     if (!$project) {
         $output->writeln('<error>Project ' . $projectName . ' does not exist </error>');
         return;
     }
     /**
      * Check if Configuration needs to be reloaded
      */
     $this->checkConfigHash($project, $input, $output);
     $service = $serviceRepository->loadServiceByName($project, $serviceName);
     /*
      * Check if Service Exists
      */
     if (!$service) {
         $output->writeln('<error>Service ' . $serviceName . ' does not exist </error>');
         return;
     }
     $output->writeln('');
     /*
      * Current Release
      */
     $currentRelease = $service->getCurrentRelease();
     $pendingRelease = $service->getPendingRelease();
     $rollbackRelease = $service->getRollbackRelease();
     $releases = $releaseRepository->findAll($project, $service);
     $rows = array();
     foreach ($releases as $release) {
         $status = '';
         $tag = $release->getTag();
         if ($pendingRelease && $release->getId() == $pendingRelease->getId()) {
             $status = '<comment>pending</comment>';
         }
         if ($currentRelease && $release->getId() == $currentRelease->getId()) {
             $status = '<info>current</info>';
         }
         if ($rollbackRelease && $release->getId() == $rollbackRelease->getId()) {
             $status = 'rollback';
         }
         $date = 'n/a';
         if ($release->getCreatedAt()) {
             $date = DateTimeHelper::humanTimeDiff($release->getCreatedAt()->getTimestamp());
         }
         $rows[] = array($tag . ' ' . $status, $date, $release->getContainerID(), $release->getContainerIp(), $release->getContainerPort(), $release->getId(), $release->getUuid());
     }
     $table = new Table($output);
     $table->setHeaders(array('Tag', 'Run Date', 'Container', 'IP', 'Port', 'ID', 'UUID'));
     $table->addRows($rows);
     $table->render();
 }

 public function execute(InputInterface $input, OutputInterface $output)
 {
     $app = $this->getSilexApplication();
     $entity = str_replace('.', '\\', $input->getArgument('entity'));
     /** @var EntityManagerInterface $em */
     $em = $app['orm.em'];
     $qb = $em->createQueryBuilder()->from($entity, 'main');
     if ($input->getOption('columns')) {
         $qb->select($input->getOption('columns'));
     } else {
         $qb->select('main');
     }
     if ($input->getOption('limit')) {
         $qb->setMaxResults($input->getOption('limit'));
         if ($input->getOption('start') !== null) {
             $qb->setFirstResult($input->getOption('start'));
         }
     }
     if ($input->getOption('filter')) {
         $qb->where($input->getOption('filter'));
     }
     $query = $qb->getQuery();
     $results = $query->getResult('simple');
     if (empty($results)) {
         $output->writeln('<info>No Results</info>');
         return;
     }
     $table = new Table($output);
     $table->setHeaders(array_keys($results[0]));
     $table->addRows($results);
     $table->render();
 }

 /**
  * @param OutputInterface $output
  * @param array           $actions
  * @param bool            $empty
  */
 protected function render(OutputInterface $output, array $actions, $empty = false)
 {
     $fields = ['action' => 'name', 'workers' => 'current-watching', 'reserved' => 'current-jobs-reserved', 'ready' => 'current-jobs-ready', 'urgent' => 'current-jobs-urgent', 'delayed' => 'current-jobs-delayed', 'buried' => 'current-jobs-buried'];
     $table = new Table($output);
     $table->setHeaders(array_keys($fields));
     $rows = [];
     foreach ($actions as $action) {
         if (!($stats = $this->manager->getActionStats($action))) {
             if (!$empty) {
                 continue;
             }
             $stats = array_combine(array_values($fields), array_fill(0, sizeof($fields), '-'));
             $stats['name'] = $action;
         }
         $rows[$action] = array_map(function ($field) use($stats) {
             return $stats[$field];
         }, $fields);
     }
     ksort($rows);
     $table->addRows($rows);
     if ($this->lineCount) {
         // move back to the beginning
         $output->write("[0G");
         $output->write(sprintf("[%dA", $this->lineCount));
         // overwrite the complete table before rendering the new one
         $width = $this->getApplication()->getTerminalDimensions()[0];
         $lines = array_fill(0, $this->lineCount, str_pad('', $width, ' '));
         $output->writeln($lines);
         $output->write(sprintf("[%dA", $this->lineCount));
     }
     // render the new table
     $table->render();
     // top table border + header + header border + bottom table border = 4
     $this->lineCount = 4 + sizeof($rows);
 }

 protected function renderConfig(OutputInterface $output, array $config)
 {
     $table = new Table($output);
     $rows = array_map(function ($a, $b) {
         return [$a, $b];
     }, array_keys($config), $config);
     $table->addRows($rows);
     $table->render();
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     list($initTime1, $finishTime1) = $this->testThread();
     list($initTime2, $finishTime2) = $this->testPool();
     $table = new Table($output);
     $table->setHeaders(['Test', 'Start Time', 'Finish Time']);
     $table->addRows([['Thread', $initTime1, $finishTime1], ['Pool', $initTime2, $finishTime2]]);
     $table->render();
 }

 /**
  * @param \ReflectionClass[] $classes
  * @param OutputInterface    $output
  */
 private function renderClassesToDeFinalize(array $classes, OutputInterface $output)
 {
     $tableHelper = new Table($output);
     if ($toDeFinalize = $this->getClassesToDeFinalize($classes)) {
         $output->writeln('<error>Following classes are final and need to be made extensible again:</error>');
         $tableHelper->addRows(array_map(function (\ReflectionClass $class) {
             return [$class->getName()];
         }, $toDeFinalize));
         $tableHelper->render();
     }
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $stringLength = $input->getOption('string-length');
     $setIterationCount = $input->getArgument('set-count');
     $getIterationCount = $input->getArgument('get-count');
     $redisTest = new Redis($input->getOption('host'), $stringLength);
     $stats = $redisTest->test($setIterationCount, $getIterationCount);
     $table = new Table($output);
     $table->setHeaders(['Count', 'Length (bytes)', 'Type', 'Time (seconds)']);
     $table->addRows([[$setIterationCount, $stringLength, 'set', $stats['set']], [$getIterationCount, $stringLength, 'get', $stats['get']]]);
     $table->render();
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $em = $this->container->getDoctrine()->getManager($input->getOption('em'));
     $users = $em->getRepository('CmsAuthentication:Group')->findBy(array(), array('name' => 'ASC'));
     $table = new Table($output);
     $table->setHeaders(array('ID', 'Name', 'Super'));
     $table->addRows(array_map(function ($group) {
         /* @var $group Group */
         return array($group->getId(), $group->getName(), $group->isSuper() ? '<info>Yes</info>' : 'No');
     }, $users));
     $table->render();
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $em = $this->container->getDoctrine()->getManager($input->getOption('em'));
     $users = $em->getRepository('CmsAuthentication:User')->findBy(array(), array('login' => 'ASC'));
     $table = new Table($output);
     $table->setHeaders(array('ID', 'Login', 'Email', 'Groups', 'Active'));
     $table->addRows(array_map(function ($user) {
         /* @var $user User */
         return array($user->getId(), $user->getLogin(), $user->getEmail(), call_user_func(function ($value) {
             if ($value instanceof Group) {
                 return $value->getName();
             } else {
                 return '--/--';
             }
         }, $user->getGroup()), $user->isActive() ? '<info>Yes</info>' : 'No');
     }, $users));
     $table->render();
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $rating = $this->nflHandler->getRating();
     $output->writeln(sprintf("<info>Rating dates:: [%s - %s]</info>", $rating["start_date"], $rating["end_date"]));
     $table = new Table($output);
     $table->setHeaders(array('Game', 'Rating', 'Predict'))->setStyle('borderless')->addRow(array(new TableCell('<error>Finished games</error>', array('colspan' => 3))));
     $output->writeln("<error>Finished games</error>");
     foreach ($rating["finished"] as $game) {
         $table->addRow(array(sprintf("%s @ %s", $game["away_team"], $game["home_team"]), $game["gex"], $game["gex_predict"]));
     }
     $table->addRows(array(new TableSeparator(), array(new TableCell('<error>Future games</error>', array('colspan' => 3)))));
     $output->writeln("");
     $output->writeln("<error>Future games</error>");
     foreach ($rating["future"] as $game) {
         $table->addRow(array(sprintf("%s @ %s", $game["away_team"], $game["home_team"]), "", $game["gex_predict"]));
     }
     $table->render();
 }

 protected function execute(InputInterface $input, OutputInterface $output)
 {
     $keys = $this->getClient()->getSshKeys();
     if (empty($keys)) {
         $this->stdErr->writeln("You do not yet have any SSH public keys in your Platform.sh account");
     } else {
         $this->stdErr->writeln("Your SSH keys are:");
         $table = new Table($output);
         $headers = array('ID', 'Title', 'Fingerprint');
         $rows = array();
         foreach ($keys as $key) {
             $rows[] = array($key['key_id'], $key['title'], $key['fingerprint']);
         }
         $table->setHeaders($headers);
         $table->addRows($rows);
         $table->render();
     }
     $this->stdErr->writeln('');
     $this->stdErr->writeln("Add a new SSH key by running <info>platform ssh-key:add [path]</info>");
     $this->stdErr->writeln("Delete an SSH key by running <info>platform ssh-key:delete [id]</info>");
 }

 public function addRows(array $rows)
 {
     $this->table->addRows($rows);
     return $this;
 }