Gets the Slick/Form default engine renderer

@return EngineInterface
166903
public static function getEngine()
    {
        if (null === self::$instance) {
            Template::addPath(self::getPath());
            $template = new Template();
            self::$instance = $template->initialize();
        }
        return self::$instance;
    }
911163
protected function registerEngineResolver()
    {
        $mySelf = $this;

        $this->container->bindShared('view.engine.resolver', function ($app) use ($mySelf) {
            $resolver = new EngineResolver();

            $mySelf->registerPhpEngine($resolver);
            $mySelf->registerBladeEngine($resolver);

            return $resolver;
        });
    }
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)
            );
        }
    }
550979
public function getRenderer() {
		if ($this->renderer === null) {
			if (php_sapi_name() === 'cli') {
				$this->renderer = new RendererCli();
				$this->renderer->setHelpersBroker(new CliHelperBrocker());
				
				return $this->renderer;
			}
			
			$this->renderer = new RendererHtml();
			$this->renderer->setAssetsPath(__DIR__ . DIRECTORY_SEPARATOR . 'Assets');
		}
		
		return $this->renderer;
	}
886442
protected function getTransformer()
    {
        $transformer = null;

        // Check if controller specifies a resource
        if (! is_null(static::$transformer)) {
            $transformer = static::$transformer;
        }

        // Otherwise, check if model is specified
        else {
            // If it is, check if the controller's model specifies the transformer
            if (! is_null(static::$model)) {
                // If it does, use it
                if (! is_null((static::$model)::$transformer)) {
                    $transformer = (static::$model)::$transformer;
                }
            }
        }

        // This is the default transformer, if one is not specified
        if (is_null($transformer)) {
            $transformer = BaseTransformer::class;
        }

        return new $transformer;
    }
585372
public function getEngine($new = false)
    {
        if (!$this->engine || $new) {
            $this->engine = new BladeEnvironment($this->getResolver(), $this->getFinder(), $this->getDispatcher());

            /** @var BladeCompiler $bladeCompiler */
            $bladeCompiler = $this->getCompiler()->getCompiler();

            foreach (GlobalContainer::getCompilers() as $name => $callback) {
                BladeExtending::extend($bladeCompiler, $name, $callback);
            }

            foreach ($this->getCustomCompilers() as $name => $callback) {
                BladeExtending::extend($bladeCompiler, $name, $callback);
            }

            foreach (GlobalContainer::getExtensions() as $name => $callback) {
                $bladeCompiler->extend($callback);
            }

            // B/C for 4.* and 5.*
            if (($rawTags = GlobalContainer::getRawTags()) && is_callable([$bladeCompiler, 'setRawTags'])) {
                $bladeCompiler->setRawTags($rawTags[0], $rawTags[1]);
            }

            if ($tags = GlobalContainer::getContentTags()) {
                $bladeCompiler->setContentTags($tags[0], $tags[1]);
            }

            if ($tags = GlobalContainer::getEscapedTags()) {
                $bladeCompiler->setEscapedContentTags($tags[0], $tags[1]);
            }
        }

        return $this->engine;
    }
547959
public com.google.appengine.v1.ScriptHandlerOrBuilder getScriptOrBuilder() {
    if (handlerTypeCase_ == 3) {
       return (com.google.appengine.v1.ScriptHandler) handlerType_;
    }
    return com.google.appengine.v1.ScriptHandler.getDefaultInstance();
  }
552734
public static function getEngine()
    {
        if (self::$nb_engine === null) {
            self::$nb_engine = new CNabuEngine();
            self::$nb_engine->init();
        }

        return self::$nb_engine;
    }
225534
public function getRenderer()
    {
        $locator = $this->getServiceLocator();
        if (null === $this->renderer && $locator->has(Renderer\RendererInterface::class)) {
            $this->setRenderer($locator->get(Renderer\RendererInterface::class));
        }

        return $this->renderer;
    }
960394
public function getTemplateEngine()
    {
        if (null == $this->templateEngine) {
            Template::addPath(dirname(dirname(__DIR__)).'/templates');
            $template = (new Template())->initialize();
            $this->setTemplateEngine($template);
        }
        return $this->templateEngine;
    }
1064263
public function render()
    {
        return $this->renderer === null
            ? $this->defaultRender()
            : (string)call_user_func($this->renderer, $this->getData());
    }
485539
protected function getDefaultValidator(): ValidatorInterface
    {
        $loaders = [new StaticMethodLoader()];

        if (class_exists(AnnotationReader::class) && class_exists(ArrayCache::class)) {
            AnnotationRegistry::registerUniqueLoader('class_exists');
            $loaders[] = new AnnotationLoader(new CachedReader(new AnnotationReader(), new ArrayCache()));
        }

        return (new ValidatorBuilder())
            ->setMetadataFactory(
                new LazyLoadingMetadataFactory(
                    new LoaderChain($loaders)
                )
            )
            ->getValidator();
    }
311176
public function getConfigTreeBuilder()
    {
        $builder = new TreeBuilder();

        $builder
            ->root('alchemy_embed')
                ->children()
                    ->arrayNode('exceptions')
                        ->addDefaultsIfNotSet()
                        ->children()
                            ->arrayNode('content_types')
                                ->fixXmlConfig('content_type')
                                ->addDefaultChildrenIfNoneSet()
                                ->prototype('scalar')
                                    ->defaultValue('application/json')
                                ->end()
                            ->end()
                            ->scalarNode('enabled')->defaultTrue()->end()
                            ->scalarNode('transformer')->defaultNull()->end()
                        ->end()
                    ->end()
                ->end()
            ->end();

        return $builder;
    }
683845
public static synchronized RenderEngine getInstance() {
    //availableEngines = null;
    if (null == availableEngines) {
      availableEngines = new HashMap();
    }

    if (!availableEngines.containsKey(DEFAULT)) {
      RenderEngine engine = new BaseRenderEngine();
      availableEngines.put(engine.getName(), engine);
    }

    return (RenderEngine) availableEngines.get(DEFAULT);
  }
207964
public function getConfigTreeBuilder()
    {
        $treeBuilder = new TreeBuilder();
        $rootNode = $treeBuilder->root('sidus_eav_model');
        /** @var NodeBuilder $attributeDefinition */
        $attributeDefinition = $rootNode
            ->children()
                ->scalarNode('data_class')->isRequired()->end()
                ->scalarNode('value_class')->isRequired()->end()
                ->booleanNode('serializer_enabled')->defaultFalse()->end()
                ->scalarNode('collection_type')->defaultValue(CollectionType::class)->end()
                ->scalarNode('context_form_type')->defaultNull()->end()
                ->variableNode('default_context')->defaultValue([])->end()
                ->arrayNode('global_context_mask')
                    ->prototype('scalar')->defaultValue([])->end()
                ->end()
                ->arrayNode('attributes')
                    ->useAttributeAsKey('code')
                    ->prototype('array')
                        ->performNoDeepMerging()
                        ->cannotBeOverwritten()
                        ->children();

        $this->appendAttributeDefinition($attributeDefinition);

        /** @var NodeBuilder $familyDefinition */
        $familyDefinition = $attributeDefinition
                        ->end()
                    ->end()
                ->end()
                ->arrayNode('families')
                    ->useAttributeAsKey('code')
                    ->prototype('array')
                        ->performNoDeepMerging()
                        ->cannotBeOverwritten()
                        ->children();

        $this->appendFamilyDefinition($familyDefinition);

        $familyDefinition
                        ->end()
                    ->end()
                ->end()
            ->end();

        return $treeBuilder;
    }
2960
public function getRenderer()
    {
        if (null === $this->renderer) {
            $this->setRenderer(new Renderer($this));
        }
        return $this->renderer;
    }
52929
public function initialize()
    {
        $engine = null;

        if (class_exists($this->_engine)) {
            $name = $this->_engine;
            $engine = new $name($this->_options);
            if (!is_a($engine, 'Slick\Template\EngineInterface')) {
                throw new Exception\InvalidArgumentException(
                    "'{$name}' is not an implementation of " .
                    "Slick\Template\EngineInterface"
                );
                
            }
            return $engine;
        }

        $this->_options['paths'] = self::$_paths;

        switch (strtolower($this->_engine)) {
            case 'twig':
                $engine = new Engine\Twig($this->_options);
                break;
            
            default:
                throw new Exception\InvalidArgumentException(
                    "Template {$this->engine} is unknown."
                );
                
        }
        return $engine;
    }