Get the compiler

@return \Illuminate\View\Compilers\BladeCompiler
540863
public function compiler()
    {
        static $engineResolver;
        if (!$engineResolver) {
            $engineResolver = $this->getContainer()->make('view.engine.resolver');
        }
        return $engineResolver->resolve('blade')->getCompiler();
    }
54528
public function getGenerator()
    {
        if (!$this->generator) {
            $this->generator = Factory::create($this->locale);
        }

        return $this->generator;
    }
717703
protected function compileRouteStub()
    {
        $stub = $this->files->get(substr(__DIR__,0, -5) . 'Stubs/route.stub');

        $this->buildStub($this->scaffoldCommandObj->getMeta(), $stub);

        return $stub;
    }
666054
public function getViewEngine()
    {
        if($this->app->exists(ViewEngineInterface::class)) {
            return $this->app->get(ViewEngineInterface::class);
        }
        $view = View::forge($this->web->view_dir);
        $this->app->set(ViewEngineInterface::class, $view, true);
        return $view;
    }
584839
public function getGenerator()
    {
        if (null !== $this->generator) {
            return $this->generator;
        }

        $compiled = is_a($this->options['generator_class'], CompiledUrlGenerator::class, true) && UrlGenerator::class === $this->options['generator_base_class'];

        if (null === $this->options['cache_dir'] || null === $this->options['generator_cache_class']) {
            $routes = $this->getRouteCollection();
            if ($compiled) {
                $routes = (new CompiledUrlGeneratorDumper($routes))->getCompiledRoutes();
            }
            $this->generator = new $this->options['generator_class']($routes, $this->context, $this->logger, $this->defaultLocale);
        } else {
            $cache = $this->getConfigCacheFactory()->cache($this->options['cache_dir'].'/'.$this->options['generator_cache_class'].'.php',
                function (ConfigCacheInterface $cache) {
                    $dumper = $this->getGeneratorDumperInstance();

                    $options = [
                        'class' => $this->options['generator_cache_class'],
                        'base_class' => $this->options['generator_base_class'],
                    ];

                    $cache->write($dumper->dump($options), $this->getRouteCollection()->getResources());
                }
            );

            if ($compiled) {
                $this->generator = new $this->options['generator_class'](require $cache->getPath(), $this->context, $this->logger);
            } else {
                if (!class_exists($this->options['generator_cache_class'], false)) {
                    require_once $cache->getPath();
                }

                $this->generator = new $this->options['generator_cache_class']($this->context, $this->logger, $this->defaultLocale);
            }
        }

        if ($this->generator instanceof ConfigurableRequirementsInterface) {
            $this->generator->setStrictRequirements($this->options['strict_requirements']);
        }

        return $this->generator;
    }
281185
public function getEngine()
    {
        if (null === $this->engine) {
            $this->setEngine(TemplateFactory::getEngine());
        }
        return $this->engine;
    }
441650
public function getStubNodeBuilder()
    {
        if (!isset($this->stubNodeBuilder)) {
            $this->stubNodeBuilder = $this->getGeneratorConfig()->getConfiguredBuilder($this->getTable(), 'nodestub');
        }

        return $this->stubNodeBuilder;
    }
1347630
protected function getRenderer()
    {
        if ($this->renderer === null) {
            $this->renderer = $this->serviceLocator->get('ViewRenderer');
        }

        return $this->renderer;
    }
463948
public function getReflector()
    {
        if ($this->reflector === null) {
            $this->reflector = new ReflectionClosure($this->closure, $this->code);
            $this->code = null;
        }

        return $this->reflector;
    }
1323831
protected function getCompiler()
    {
        if ($this->compiler === null) {
            $this->compiler = new Compiler();
            $this->compiler->setFormatter($this->formatter);
        }
        return $this->compiler;
    }
1174584
public function getBuilder()
    {
        $builder = new Query\Builder();
        $builder->setVisitors([
            (new Visitors\KeyVisitor($builder))->setKeys($this->keys)->setBaseTable($this->table),
            new Visitors\GroupVisitor($builder),
            new Visitors\EqVisitor($builder),
            new Visitors\NotEqVisitor($builder),
            new Visitors\GtVisitor($builder),
            new Visitors\GteVisitor($builder),
            new Visitors\LtVisitor($builder),
            new Visitors\LteVisitor($builder),
            new Visitors\CtVisitor($builder),
            new Visitors\SwVisitor($builder),
            new Visitors\EwVisitor($builder),
            new Visitors\AndVisitor($builder),
            new Visitors\OrVisitor($builder),
            new Visitors\NotInVisitor($builder),
            new Visitors\InVisitor($builder),
            new Visitors\NullVisitor($builder),
            new Visitors\NotNullVisitor($builder),
        ]);
        $builder->setFunctions([
            new Functions\ConcatFunction(),
            new Functions\SumFunction(),
        ]);

        return $builder;
    }
219660
protected function getAssembler()
    {
        if (!$this->assembler) {
            $this->assembler = Ioc::make(EntityAssembler::class);
        }

        return $this->assembler;
    }
130953
public function getViewBuilder()
    {
        if (null === $this->viewBuilder) {
            $this->viewBuilder = new View\ViewBuilder();
            $this->viewBuilder->setEditor($this);
        }

        return $this->viewBuilder;
    }
323151
public function getConverter()
    {
        if ($this->_converter === null) {
            $this->_converter = $this->app->createObject(AssetConverter::class);
        } elseif (is_array($this->_converter) || is_string($this->_converter)) {
            if (is_array($this->_converter) && !isset($this->_converter['__class'])) {
                $this->_converter['__class'] = AssetConverter::class;
            }
            $this->_converter = $this->app->createObject($this->_converter);
        }

        return $this->_converter;
    }
94884
public function getEngine() {
        if (!$this->_engine) {
            $engine = new \Decoda\Engine\PhpEngine();
            $engine->addPath(dirname(__DIR__) . '/templates/');

            $this->setEngine($engine);
        }

        return $this->_engine;
    }
166903
public static function getEngine()
    {
        if (null === self::$instance) {
            Template::addPath(self::getPath());
            $template = new Template();
            self::$instance = $template->initialize();
        }
        return self::$instance;
    }
73480
public function getEngine()
    {
        if (is_null($this->_engine)) {
            $template = new Template($this->engineOptions);
            $this->_engine = $template->initialize();
        }
        return $this->_engine;
    }