Render the passed $renderable and return the rendered Renderable.

@param RootRenderableInterface $renderable
@return string the rendered $renderable
@throws RenderingException
@api
548199
public function renderRenderable(RootRenderableInterface $renderable)
    {
        $renderable->beforeRendering($this->formRuntime);

        $renderableType = $renderable->getType();

        if ($renderable->getRendererClassName() !== null && $renderable->getRendererClassName() !== get_class($this)) {
            $rendererClassName = $renderable->getRendererClassName();
            $renderer = new $rendererClassName;
            if (!($renderer instanceof RendererInterface)) {
                throw new RenderingException(sprintf('The renderer class "%s" for "%s" does not implement RendererInterface.', $rendererClassName, $renderableType), 1326098022);
            }
            $renderer->setControllerContext($this->controllerContext);
            $renderer->setFormRuntime($this->formRuntime);
            return $renderer->renderRenderable($renderable);
        }

        $renderingOptions = $renderable->getRenderingOptions();

        $renderablePathAndFilename = $this->getPathAndFilenameForRenderable($renderableType, $renderingOptions);
        $parsedRenderable = $this->getParsedRenderable($renderable->getType(), $renderablePathAndFilename);
        $currentTemplatePathsResolver = $this->getTemplatePaths();
        $newTemplatePathsResolver = $this->createTemplatePathsResolverWithRenderingOptions($renderingOptions);
        $this->baseRenderingContext->setTemplatePaths($newTemplatePathsResolver);

        if ($this->getCurrentRenderingContext() === null) {
            // We do not have a "current" rendering context yet, so we use the base rendering context
            $this->baseRenderingContext->setControllerContext($this->controllerContext);
            $renderingContext = $this->baseRenderingContext;
        } else {
            $renderingContext = clone $this->getCurrentRenderingContext();
        }
        $renderingContext->getViewHelperVariableContainer()->addOrUpdate(FluidFormRenderer::class, 'currentRenderable', $renderable);

        if (!isset($renderingOptions['renderableNameInTemplate'])) {
            throw new RenderingException(sprintf('The Renderable "%s" did not have the rendering option "renderableNameInTemplate" defined.', $renderableType), 1326094948);
        }

        $templateVariableContainer = new TemplateVariableContainer(array($renderingOptions['renderableNameInTemplate'] => $renderable));
        $renderingContext->setVariableProvider($templateVariableContainer);

        if ($parsedRenderable->hasLayout()) {
            $renderableLayoutName = $parsedRenderable->getLayoutName($renderingContext);
            $renderableLayoutPathAndFilename = $this->getPathAndFilenameForRenderableLayout($renderableLayoutName, $renderingOptions);
            $parsedLayout = $this->getParsedRenderable($renderableLayoutName, $renderableLayoutPathAndFilename);

            $this->startRendering(self::RENDERING_LAYOUT, $parsedRenderable, $renderingContext);
            $output = $parsedLayout->render($renderingContext);
            $this->stopRendering();
        } else {
            $this->startRendering(self::RENDERING_TEMPLATE, $parsedRenderable, $renderingContext);
            $output = $parsedRenderable->render($renderingContext);
            $this->stopRendering();
        }

        $this->baseRenderingContext->setTemplatePaths($currentTemplatePathsResolver);
        $output = $this->formRuntime->invokeRenderCallbacks($output, $renderable);
        return $output;
    }
821003
public function renderContainerVariable(
        VariableAwareInterface $root,
        $propertyPath = null,
        VariableAwareInterface $object = null
    ) {
        $variable = $root->getVariable().'_container';

        if ($propertyPath !== null) {
            $variable = $this->renderProperty($variable, $propertyPath);
        }

        if ($object !== null) {
            $variable = $this->renderProperty($variable, $object->getVariable());
        }

        return $variable;
    }
435022
public function render($template, array $parameters = [])
    {
        $resource = $this->loadTemplate($template);

        $this->stack->push([
            $resource,
            $this->mergeShared($this->getParameters($template, $parameters))
        ]);

        $hash = $resource->getHash();

        if (isset($this->parents[$hash])) {
            throw new RenderException(sprintf('Circular reference in %s.', $template));
        }

        unset($this->parents[$hash]);

        $this->startErrorHandling();

        $content = $this->doRender();

        if (isset($this->parents[$hash])) {
            $content = $this->render($this->parents[$hash], $parameters);
        }

        $this->stopErrorHandling();

        $this->stack->pop();

        return $content;
    }
1023830
public function getRenderablesRecursively()
    {
        $renderables = [];
        foreach ($this->renderables as $renderable) {
            $renderables[] = $renderable;
            if ($renderable instanceof CompositeRenderableInterface) {
                $renderables = array_merge($renderables, $renderable->getRenderablesRecursively());
            }
        }
        return $renderables;
    }
591375
public function render_summary(renderable $summary) {
        $data = $summary->export_for_template($this);
        return parent::render_from_template('block_lp/summary', $data);
    }
345757
protected function _render()
    {
        try {
            $template = $this->_getTemplate();
            $context  = $this->_getContextFor($template);

            return $this->_renderTemplate($template, $context);
        } catch (RootException $e) {
            throw $this->_throwCouldNotRenderException($this->__('Could not render template'), null, $e);
        }
    }
75198
protected function renderTextMessage($throwable)
    {
        $message = $this->getSummary();
        if ($this->displayErrorDetails()) {
            $prev = $this->translator()->translate('Previous error:', [], 'charcoal');

            $message .= PHP_EOL.$this->renderThrowableAsText($throwable);
            while ($throwable = $throwable->getPrevious()) {
                $message .= PHP_EOL.$prev.PHP_EOL;
                $message .= $this->renderThrowableAsText($throwable);
            }
        }

        return $message;
    }
413461
public function render(Renderable $renderer, $view, $argv = null, $displayImmediately = false)
    {
        $this->renderer = $renderer;
        $this->createAdapter();
        if (is_array($argv) && !empty($argv)) foreach ($argv as $k=>$v) {
            $this->adapter->assignVar($k, $v);
        }
        $this->adapter->assignVar('application', \Devil::app());
        $this->adapter->assignVar('this', $this->renderer);
        if ($displayImmediately) {
            $this->adapter->display($view);
            return true;
        } else {
            return $this->adapter->fetch($view);
        }
    }
1135238
public function render(array $arguments = [], $renderer = null) {
        if(empty($this->itemsToDisplay)) {
            return $this->button->render($arguments);
        }

        return $this->baseRender($arguments, $renderer);
    }
799475
protected function addRenderFormat(RenderInterface $renderer)
    {
        foreach ($renderer->getSupportedFormats() as $format) {
            $this->renderers[$format] = $renderer;
        }
    }
1245995
public function getRender()
    {
        if ($this->render) {
            return $this->render;
        }

        $renderType = $this->getRenderType();

        if (!$renderType) {
            return false;
        }

        if (class_exists($renderType)) {
            $className = $renderType;
        } else {
            $className = str_replace('_', ' ', $renderType);
            $className = ucwords(strtolower($className));
            $className = str_replace(' ', '', $className);

            $className = 'PedroTeixeira\Bundle\GridBundle\Grid\Render\\' . $className;
        }

        try {
            $reflection = new \ReflectionClass($className);

            $this->render = $reflection->newInstance(
                $this->container
            );

            return $this->render;
        } catch (\Exception $e) {
            throw new \Exception(
                sprintf('Grid render type "%s" doesn\'t exist', $renderType)
            );
        }
    }
1356761
protected function render_rules(rules $renderable) {
        $o = '';
        if (!empty($renderable->totalcount)) {
            $o .= $this->render_table($renderable);
        }
        return $o;
    }
912053
protected function render(ElementInterface $element)
    {
        $renderer = $this->getView();

        if (!method_exists($renderer, 'plugin')) {
            throw new Exception\RuntimeException(
                'Renderer does not have a plugin method.'
            );
        }

        if ($element instanceof FormElement\Button) {
            $helper = $renderer->plugin('sxb_button');

            return $helper($element);
        }

        if ($element instanceof FormElement\Captcha) {
            $helper = $renderer->plugin('form_captcha');

            return $helper($element);
        }

        if ($element instanceof FormElement\Csrf) {
            $helper = $renderer->plugin('sxb_form_hidden');

            return $helper($element);
        }

        if ($element instanceof FormElement\Collection) {
            $helper = $renderer->plugin('form_collection');

            return $helper($element);
        }

        if ($element instanceof FormElement\DateTimeSelect) {
            $helper = $renderer->plugin('form_date_time_select');

            return $helper($element);
        }

        if ($element instanceof FormElement\DateSelect) {
            $helper = $renderer->plugin('form_date_select');

            return $helper($element);
        }

        if ($element instanceof FormElement\MonthSelect) {
            $helper = $renderer->plugin('form_month_select');

            return $helper($element);
        }

        $type = $element->getAttribute('type');

        if ('checkbox' === $type) {
            $helper = $renderer->plugin('form_checkbox');

            return $helper($element);
        }

        if ('color' === $type) {
            $helper = $renderer->plugin('sxb_form_color');

            return $helper($element);
        }

        if ('date' === $type) {
            $helper = $renderer->plugin('sxb_form_date');

            return $helper($element);
        }

        if ('datetime' === $type) {
            $helper = $renderer->plugin('sxb_form_date_time');

            return $helper($element);
        }

        if ('datetime-local' === $type) {
            $helper = $renderer->plugin('sxb_form_date_time_local');

            return $helper($element);
        }

        if ('email' === $type) {
            $helper = $renderer->plugin('sxb_form_email');

            return $helper($element);
        }

        if ('file' === $type) {
            $helper = $renderer->plugin('sxb_form_file');

            return $helper($element);
        }

        if ('hidden' === $type) {
            $helper = $renderer->plugin('sxb_form_hidden');

            return $helper($element);
        }

        if ('image' === $type) {
            $helper = $renderer->plugin('sxb_form_image');

            return $helper($element);
        }

        if ('month' === $type) {
            $helper = $renderer->plugin('sxb_form_month');

            return $helper($element);
        }

        if ('multi_checkbox' === $type) {
            $helper = $renderer->plugin('form_multi_checkbox');

            return $helper($element);
        }

        if ('number' === $type) {
            $helper = $renderer->plugin('sxb_form_number');

            return $helper($element);
        }

        if ('password' === $type) {
            $helper = $renderer->plugin('sxb_form_password');

            return $helper($element);
        }

        if ('radio' === $type) {
            $helper = $renderer->plugin('form_radio');

            return $helper($element);
        }

        if ('range' === $type) {
            $helper = $renderer->plugin('sxb_form_range');

            return $helper($element);
        }

        if ('reset' === $type) {
            $helper = $renderer->plugin('sxb_form_reset');

            return $helper($element);
        }

        if ('search' === $type) {
            $helper = $renderer->plugin('sxb_form_search');

            return $helper($element);
        }

        if ('select' === $type) {
            $helper = $renderer->plugin('form_select');

            return $helper($element);
        }

        if ('submit' === $type) {
            $helper = $renderer->plugin('sxb_form_submit');

            return $helper($element);
        }

        if ('tel' === $type) {
            $helper = $renderer->plugin('sxb_form_tel');

            return $helper($element);
        }

        if ('text' === $type) {
            $helper = $renderer->plugin('sxb_form_input');

            return $helper($element);
        }

        if ('textarea' === $type) {
            $helper = $renderer->plugin('form_textarea');

            return $helper($element);
        }

        if ('time' === $type) {
            $helper = $renderer->plugin('sxb_form_time');

            return $helper($element);
        }

        if ('url' === $type) {
            $helper = $renderer->plugin('sxb_form_url');

            return $helper($element);
        }

        if ('week' === $type) {
            $helper = $renderer->plugin('sxb_form_week');

            return $helper($element);
        }

        $helper = $renderer->plugin('sxb_form_input');

        return $helper($element);
    }
947639
protected function doRender()
    {
        list($resource, $parameters) = $this->getCurrent();

        ob_start();
        try {

            if ($resource instanceof FileResource) {
                $this->displayFile($resource, $parameters);
            } elseif ($resource instanceof StringResource) {
                $this->displayString($resource, $parameters);
            }

        } catch (\Exception $e) {
            ob_end_clean();

            if ($e instanceof TemplateException) {
                throw $e;
            }

            throw new RenderException($e->getMessage(), $e, $e->getCode());
        }

        return ob_get_clean();
    }
1115357
function (renderable) {
                if (!renderable) {
                    throw new ArgumentError(
                        Logger.logMessage(Logger.LEVEL_SEVERE, "GeoJSONExporter", "exportRenderable",
                            "missingRenderable"));
                }

                if (renderable instanceof WorldWind.Placemark) {
                    return this.exportPlacemark(renderable);
                }
                else if (renderable instanceof WorldWind.SurfacePolyline) {
                    return this.exportSurfacePolyline(renderable);
                }
                else if (renderable instanceof WorldWind.SurfacePolygon) {
                    return this.exportSurfacePolygon(renderable);
                }
                else if (renderable instanceof WorldWind.SurfaceEllipse) {
                    return this.exportSurfaceEllipse(renderable);
                }
                else if (renderable instanceof WorldWind.SurfaceCircle) {
                    return this.exportSurfaceCircle(renderable);
                }
                else if (renderable instanceof WorldWind.SurfaceRectangle) {
                    return this.exportSurfaceRectangle(renderable);
                }
                else if (renderable instanceof WorldWind.SurfaceSector) {
                    return this.exportSurfaceSector(renderable);
                }
                else if (renderable instanceof WorldWind.Path) {
                    return this.exportPath(renderable);
                }
                else if (renderable instanceof WorldWind.Polygon) {
                    return this.exportPolygon(renderable);
                }
                else {
                    Logger.log(Logger.LEVEL_WARNING, "Export renderable not implemented: " + renderable);
                    return null;
                }
            }
978234
public function render( RendererInterface $renderer, $content, array $params )
    {
        return $renderer->render(
            $this->getTemplate(),
            $this->getVariables( array_merge( $params, array(
                'content' => $content,
            ) ) )
        );
    }
153553
protected function render_insights_list(renderable $renderable) {
        $data = $renderable->export_for_template($this);
        return parent::render_from_template('report_insights/insights_list', $data);
    }