Render reports (as opposed to just generating the report XML documents via. generateReports).

@param OutputInterface $output
@param SuiteCollection $collection
@param array $reportNames
@param array $outputNames
540397
public function renderReports(OutputInterface $output, SuiteCollection $collection, array $reportNames, array $outputNames)
    {
        $reportDoms = $this->generateReports($collection, $reportNames);

        foreach ($outputNames as $outputName) {
            $outputConfig = $this->rendererRegistry->getConfig($outputName);
            $renderer = $this->rendererRegistry->getService($outputConfig['renderer']);
            assert($renderer instanceof RendererInterface);

            // set the output instance if the renderer requires it.
            if ($renderer instanceof OutputAwareInterface) {
                $renderer->setOutput($output);
            }

            foreach ($reportDoms as $reportDom) {
                $renderer->render($reportDom->duplicate(), $outputConfig);
            }
        }
    }
125848
def generate_report(self, output_file):
        

        if self.TEMPLATE_NAME is not None:
            template = TEMPLATE_ENV.get_template(self.TEMPLATE_NAME)
            report = template.render(self._context())

            if isinstance(report, six.string_types):
                report = report.encode('utf-8')

            output_file.write(report)
474655
public void setOutputChannels(java.util.Collection<OutputChannelMapping> outputChannels) {
        if (outputChannels == null) {
            this.outputChannels = null;
            return;
        }

        this.outputChannels = new java.util.ArrayList<OutputChannelMapping>(outputChannels);
    }
1321271
public function generateFixtures(
        BundleInterface $bundle,
        array $parameters,
        OutputInterface $output
    ) {
        $dirPath = $bundle->getPath() . '/DataFixtures/ORM/SearchPageGenerator/';
        $skeletonDir = $this->skeletonDir . '/DataFixtures/ORM/SearchPageGenerator/';

        try {
            $this->generateSkeletonBasedClass(
                $skeletonDir,
                $dirPath,
                'SearchFixtures',
                $parameters
            );
        } catch (\Exception $error) {
            throw new \RuntimeException($error->getMessage());
        }

        $output->writeln('Generating fixtures : <info>OK</info>');
    }
768353
public void setOutputDetails(java.util.Collection<OutputDetail> outputDetails) {
        if (outputDetails == null) {
            this.outputDetails = null;
            return;
        }

        this.outputDetails = new java.util.ArrayList<OutputDetail>(outputDetails);
    }
965643
protected function addOutputFormatterStyles(OutputInterface $output)
    {
        foreach ($this->getOutputFormatterStyles() as $name => $style) {
            $output->getFormatter()->setStyle($name, $style);
        }
    }
62321
protected function listExport(OutputInterface $output)
    {
        $table = new Table($output);

        foreach ((new ExportQuery)->find() as $export) {
            $table->addRow([
                $export->getRef(),
                $export->getTitle(),
                $export->getDescription()
            ]);
        }

        $table
            ->setHeaders([
                'Reference',
                'Title',
                'Description'
            ])
            ->render()
        ;
    }
801418
public static void writeCollection(XMLOutput xmlOutput, Collection<? extends XMLWriteable> collection) throws IOException {
        for (XMLWriteable obj : collection) {
            obj.writeXML(xmlOutput);
        }
    }
41777
protected function printDbBuildVersion(OutputInterface $output) : void
    {
        $output->writeln(
            sprintf(
                '<info>Reference Database Version</info> => %s%s',
                $this->getApplication()->getDbVersions()['build.version'],
                PHP_EOL

            )
        );
    }
4908
public void setOutputs(java.util.Collection<Output> outputs) {
        if (outputs == null) {
            this.outputs = null;
            return;
        }

        this.outputs = new com.amazonaws.internal.SdkInternalList<Output>(outputs);
    }
279373
public function runExport(array $options, OutputInterface $output)
    {
        $options = $this->validate($options);

        $options['contentTypeIds'] = Text::getIdListFromString($options['contentTypeIdList']);
        $chunkDir = $this->fileSystemHelper->createChunkDir();

        $languages = $this->getLanguages($options);
        $options['languages'] = $languages;

        try {
            $this->fileSystemHelper->lock();
            $urls = $this->generateFiles($languages, $chunkDir, $options, $output);
            $this->fileSystemHelper->unlock();

            $credentials = $this->authenticator->getCredentials();
            $securedDirCredentials = $this->fileSystemHelper->secureDir($chunkDir, $credentials);

            $response = $this->exportNotifier->sendRecommendationResponse($urls, $options, $securedDirCredentials);
            $this->logger->info(sprintf('eZ Recommendation Response: %s', $response));
            $output->writeln('Done');
        } catch (Exception $e) {
            $this->logger->error(sprintf('Error while generating export: %s', $e->getMessage()));
            $this->fileSystemHelper->unlock();

            throw $e;
        }
    }
702215
private function connectOutputToEvents(OutputInterface $output)
    {
        $this->getHelper('phpdocumentor_logger')->connectOutputToLogging($output, $this);

        Dispatcher::getInstance()->addListener(
            Transformer::EVENT_PRE_TRANSFORM,
            function (PreTransformEvent $event) use ($output) {
                $transformations = $event->getSubject()->getTemplates()->getTransformations();
                $output->writeln(sprintf("\nApplying %d transformations", count($transformations)));
            }
        );
        Dispatcher::getInstance()->addListener(
            Transformer::EVENT_PRE_INITIALIZATION,
            function (WriterInitializationEvent $event) use ($output) {
                $output->writeln('  Initialize writer "' . get_class($event->getWriter()) . '"');
            }
        );
        Dispatcher::getInstance()->addListener(
            Transformer::EVENT_PRE_TRANSFORMATION,
            function (PreTransformationEvent $event) use ($output) {
                $output->writeln(
                    '  Execute transformation using writer "' . $event->getTransformation()->getWriter() . '"'
                );
            }
        );
    }
1168180
public function render(OutputInterface $output, ResultCollection $results)
    {
        $output->writeln($this->getHeader());

        foreach ($results->toArray() as $result) {
            $output->writeln(implode(';', [ '"'.$result[0].'"', $result[1], $result[2], $result[3] ]));
        };
    }
924523
private function createOperationOutput(array &$output, OperationInterface $operation)
    {
        $operationHandler = $this->getOperationHandler($operation);

        if (!$operationHandler) {
            return;
        }

        $output[] = '';

        $urlGenerator = $this->getUrlGenerator(
            $operationHandler->extractSourceUrl($operation)
        );

        $output = array_merge(
            $output,
            $operationHandler->getOutput($operation, $urlGenerator)
        );
    }
1240632
public void setOutputUpdates(java.util.Collection<OutputUpdate> outputUpdates) {
        if (outputUpdates == null) {
            this.outputUpdates = null;
            return;
        }

        this.outputUpdates = new java.util.ArrayList<OutputUpdate>(outputUpdates);
    }
774684
public function generateReport(
        $idReport,
        $language = '',
        $outputType = '',
        $reportFormat = '',
        $parameters = '',
        array $optional = []
    )
    {
        return $this->_request('ScheduledReports.generateReport', [
            'idReport' => $idReport,
            'language' => $language,
            'outputType' => $outputType,
            'reportFormat' => $reportFormat,
            'parameters' => $parameters,
        ], $optional);
    }
533921
protected function listKnownSheets(OutputInterface $output)
    {
        $output->writeln('Please enter one of the configured Sheet names');

        $table = new Table($output);
        $table->setHeaders(['Sheet Name', 'URL']);

        foreach ($this->googleApiService->getMapping() as $mappingName => $mappingProperties) {
            if (isset($mappingProperties['url'])) {
                $table->addRow([$mappingName, $mappingProperties['url']]);
            }
        }

        $table->render();
    }