PHP Factory::setContainer方法代码示例

 public function __construct()
 {
     $this->instance('container', $this);
     $this->singleton('events', function () {
         return new Dispatcher();
     });
     $this->singleton('files', function () {
         return new Filesystem();
     });
     $this->singleton('blade.compiler', function () {
         return new BladeCompiler($this['files'], $this['view.compiled']);
     });
     $this->singleton('view.engine.resolver', function () {
         $resolver = new EngineResolver();
         $resolver->register('blade', function () {
             return new CompilerEngine($this['blade.compiler'], $this['files']);
         });
         $resolver->register('php', function () {
             return new PhpEngine();
         });
         return $resolver;
     });
     $this->singleton('view.finder', function () {
         return new FileViewFinder($this['files'], $this['view.paths']);
     });
     $this->singleton('view', function () {
         $env = new Factory($this['view.engine.resolver'], $this['view.finder'], $this['events']);
         $env->setContainer($this['container']);
         return $env;
     });
 }

 public function register(Container $pimple)
 {
     $pimple['files'] = function () {
         return new Filesystem();
     };
     $pimple['view.engine.resolver'] = function () use($pimple) {
         $resolver = new EngineResolver();
         foreach (['php', 'blade'] as $engine) {
             $this->{'register' . ucfirst($engine) . 'Engine'}($resolver, $pimple);
         }
         return $resolver;
     };
     $pimple['view.finder'] = function () use($pimple) {
         $paths = $pimple['config']['view.paths'];
         return new FileViewFinder($pimple['files'], $paths);
     };
     $pimple['view'] = function () use($pimple) {
         // Next we need to grab the engine resolver instance that will be used by the
         // environment. The resolver will be used by an environment to get each of
         // the various engine implementations such as plain PHP or Blade engine.
         $resolver = $pimple['view.engine.resolver'];
         $finder = $pimple['view.finder'];
         $env = new Factory($resolver, $finder, $pimple['events']);
         // We will also set the container instance on this view environment since the
         // view composers may be classes registered in the container, which allows
         // for great testable, flexible composers for the application developer.
         $env->setContainer($pimple['container']);
         $env->share('app', $pimple);
         return $env;
     };
 }

 protected function makeView()
 {
     $app = new Container();
     $resolver = new EngineResolver();
     $resolver->register('php', function () {
         return new PhpEngine();
     });
     $finder = new FileViewFinder(new Filesystem(), [realpath(__DIR__)]);
     $dispatcher = (new Dispatcher($app))->setQueueResolver(function () use($app) {
         return $app->make('Illuminate\\Contracts\\Queue\\Factory');
     });
     $env = new Factory($resolver, $finder, $dispatcher);
     $env->setContainer($app);
     $env->share('app', $app);
     return new Illuminate($env);
 }

 /**
  * Register the view environment.
  *
  * @return void
  */
 public function registerFactory()
 {
     $this->app->singleton('view', function ($app) {
         // Next we need to grab the engine resolver instance that will be used by the
         // environment. The resolver will be used by an environment to get each of
         // the various engine implementations such as plain PHP or Blade engine.
         $resolver = $app['view.engine.resolver'];
         $finder = $app['view.finder'];
         $env = new Factory($resolver, $finder, $app['events']);
         // We will also set the container instance on this view environment since the
         // view composers may be classes registered in the container, which allows
         // for great testable, flexible composers for the application developer.
         $env->setContainer($app);
         $env->share('app', $app);
         return $env;
     });
 }

 /**
  * Set the IoC container instance.
  *
  * @param \Illuminate\Contracts\Container\Container $container
  * @return void 
  * @static 
  */
 public static function setContainer($container)
 {
     \Illuminate\View\Factory::setContainer($container);
 }

 /**
  * Register the view factory.
  */
 public function registerFactory()
 {
     $resolver = $this->container['view.engine.resolver'];
     $finder = $this->container['view.finder'];
     $factory = new Factory($resolver, $finder, $this->container['events']);
     $factory->setContainer($this->container);
     $this->viewFactory = $factory;
 }

 /**
  * @param Container $app
  */
 public function register(Container $app)
 {
     // we only need to do this if Blade views are enabled.
     if ($app['config']['view.blade.enabled']) {
         $app['blade.settings'] = $app['config']['view.blade.defaults'];
         $app['blade.template.paths'] = $app['blade.settings']['template_paths'];
         $app['files'] = function () {
             return new Filesystem();
         };
         $app['view.finder'] = function ($app) {
             return new FileViewFinder(new Filesystem(), $app['blade.template.paths']);
         };
         // create the Blade compiler using Filesystem and cache directory
         $app['blade.compiler'] = function ($app) {
             return new BladeCompiler(new Filesystem(), $app['blade.settings']['cache']);
         };
         // get a blade compiler engine instance
         $app['blade.engine'] = function ($app) {
             return new CompilerEngine($app['blade.compiler']);
         };
         $app['view.engine.resolver'] = function ($app) {
             $resolver = new EngineResolver();
             $resolver->register('php', function () {
                 return new PhpEngine();
             });
             $resolver->register('blade', function () use($app) {
                 return new CompilerEngine($app['blade.compiler'], $app['files']);
             });
             return $resolver;
         };
         $app['blade.factory'] = function ($app) {
             $view_factory = new IlluminateViewFactory($app['view.engine.resolver'], $app['view.finder'], $app['illuminate.events']);
             $view_factory->setContainer($app['nine.container']);
             return $view_factory;
         };
     }
 }

 /**
  * bindIlluminateView
  *
  * @param  Container  $app
  * @param  array      $viewPaths
  * @param  string     $cachePath
  * @return Container
  */
 public function bindIlluminateView(Container $app = null, array $viewPaths = array(), $cachePath)
 {
     if (!$app) {
         $app = new Container();
     }
     $this->ensureIlluminateBase($app);
     $app->bindShared('view.engine.resolver', function (Container $app) {
         $resolver = new EngineResolver();
         $resolver->register('php', function () {
             return new PhpEngine();
         });
         $app->bindShared('blade.compiler', function (Container $app) {
             $cache = $this->illuminateCachePath;
             return new BladeCompiler($app['files'], $cache);
         });
         $resolver->register('blade', function () use($app) {
             return new CompilerEngine($app['blade.compiler'], $app['files']);
         });
         return $resolver;
     });
     $app->bindShared('view.finder', function (Container $app) {
         $paths = $this->illuminateViewPaths;
         return new FileViewFinder($app['files'], $paths);
     });
     $app->bindShared('view', function (Container $app) {
         $env = new ViewFactory($app['view.engine.resolver'], $app['view.finder'], $app['events']);
         $env->setContainer($app);
         return $env;
     });
     return $app;
 }

 /**
  *
  * @return Factory
  */
 protected function getViewFactory()
 {
     $factory = new Factory($this->container['view.engine.resolver'], $this->container['view.finder'], $this->container['events']);
     $factory->setContainer($this->container);
     return $factory;
 }

 /**
  * Register the view factory. The factory is
  * available in all views.
  */
 protected function registerViewFactory()
 {
     // Register the View Finder first.
     $this->app->singleton('view.finder', function ($container) {
         return new ViewFinder($container['filesystem'], [], ['blade.php', 'scout.php', 'twig', 'php']);
     });
     $this->app->singleton('view', function ($container) {
         $factory = new Factory($container['view.engine.resolver'], $container['view.finder'], $container['events']);
         // Set the container.
         $factory->setContainer($container);
         // Tell the factory to also handle the scout template for backwards compatibility.
         $factory->addExtension('scout.php', 'blade');
         // Tell the factory to handle twig extension files and assign them to the twig engine.
         $factory->addExtension('twig', 'twig');
         // We will also set the container instance on this view environment since the
         // view composers may be classes registered in the container, which allows
         // for great testable, flexible composers for the application developer.
         $factory->setContainer($container);
         $factory->share('app', $container);
         return $factory;
     });
 }