PHP Container::offsetExists方法代码示例

 /**
  * Set defaults and build the conneg service.
  *
  * @param Container $app
  * @throws ServiceUnavailableHttpException
  */
 public function register(Container $app)
 {
     $app["conneg.responseFormats"] = array("html");
     $app["conneg.requestFormats"] = array("form");
     $app["conneg.defaultFormat"] = "html";
     $app["conneg"] = function (Container $app) {
         if ($app->offsetExists("serializer")) {
             if ($app["serializer"] instanceof JMS\Serializer) {
                 if (!$app->offsetExists("conneg.serializationContext")) {
                     $app["conneg.serializationContext"] = null;
                 }
                 if (!$app->offsetExists("conneg.deserializationContext")) {
                     $app["conneg.deserializationContext"] = null;
                 }
                 return new JmsSerializerContentNegotiation($app);
             } elseif ($app["serializer"] instanceof SymfonySerializer\Serializer) {
                 if (!$app->offsetExists("conneg.serializationContext")) {
                     $app["conneg.serializationContext"] = array();
                 }
                 if (!$app->offsetExists("conneg.deserializationContext")) {
                     $app["conneg.deserializationContext"] = array();
                 }
                 return new SymfonySerializerContentNegotiation($app);
             }
         }
         throw new ServiceUnavailableHttpException(null, "No supported serializer found");
     };
 }

 /**
  * @param Container $container the dependency injection container.
  */
 public function register(Container $container)
 {
     if (!$container->offsetExists('token.length')) {
         $container['token.length'] = TokenCreator::DEFAULT_LENGTH;
     }
     if (!$container->offsetExists('token.case')) {
         $container['token.case'] = TokenCreator::UPPER;
     }
     $container['token'] = function ($container) {
         return new TokenCreator($container['token.length'], $container['token.case']);
     };
 }

 public function register(Container $container)
 {
     $cid = $this->cid;
     $container[$cid] = $container->factory(function () use($cid, $container) {
         $get = function ($key, $default = null) use($container, $cid) {
             $key = $cid . '.' . $key;
             return $container->offsetExists($key) ? $container->offsetGet($key) : $default;
         };
         $adapterName = $get('adapter');
         switch ($adapterName) {
             case 'redis':
                 $adapter = new AdapterPureRedis(['host' => $get('host'), 'port' => $get('port'), 'timeout' => $get('timeout'), 'password' => $get('password'), 'dbIndex' => $get('dbIndex')]);
                 break;
             case 'file':
                 $adapter = new AdapterFile($get('dir'));
                 break;
             default:
                 $adapter = new AdapternotCache();
                 break;
         }
         foreach ($get('options', []) as $k => $v) {
             $adapter->setOption($k, $v);
         }
         return new Cache($adapter);
     });
 }

 /**
  * @param Container $pimple
  */
 public function register(Container $pimple)
 {
     // Default extractor, inflector and middleware setup
     $pimple['tactician.extractor'] = new ClassNameExtractor();
     $pimple['tactician.inflector'] = new HandleInflector();
     $pimple['tactician.middleware'] = [new LockingMiddleware()];
     // Set (default tactician) locator only when not already set before
     if (!$pimple->offsetExists('tactician.locator')) {
         $pimple['tactician.locator'] = function () {
             return new InMemoryLocator();
         };
     }
     // Setup command bus
     $pimple['tactician.command_bus'] = function () use($pimple) {
         if (is_string($pimple['tactician.extractor'])) {
             $pimple['tactician.extractor'] = new $pimple['tactician.extractor']();
         }
         if (is_string($pimple['tactician.inflector'])) {
             $pimple['tactician.inflector'] = new $pimple['tactician.inflector']();
         }
         // Add handler middleware to existing set of middleware
         $middleware = $pimple['tactician.middleware'];
         $middleware[] = new CommandHandlerMiddleware($pimple['tactician.extractor'], $pimple['tactician.locator'], $pimple['tactician.inflector']);
         return new CommandBus($middleware);
     };
 }

 /**
  * @param Container|Application $app
  */
 public function register(Container $app)
 {
     if (!$app->offsetExists('annot.useServiceControllers')) {
         $app['annot.useServiceControllers'] = true;
     }
     $app["annot"] = function (Container $app) {
         return new AnnotationService($app);
     };
     // A custom auto loader for Doctrine Annotations since it can't handle PSR-4 directory structure
     AnnotationRegistry::registerLoader(function ($class) {
         return class_exists($class);
     });
     // Register ServiceControllerServiceProvider here so the user doesn't have to.
     if ($app['annot.useServiceControllers']) {
         $app->register(new ServiceControllerServiceProvider());
     }
     // this service registers the service controller and can be overridden by the user
     $app['annot.registerServiceController'] = $app->protect(function ($controllerName) use($app) {
         if ($app['annot.useServiceControllers']) {
             $app["{$controllerName}"] = function (Application $app) use($controllerName) {
                 return new $controllerName($app);
             };
         }
     });
     $app['annot.controllerFinder'] = $app->protect(function (Application $app, $dir) {
         return $app['annot']->getFiles($dir, $app['annot.controllerNamespace']);
     });
     /** @noinspection PhpUnusedParameterInspection */
     $app['annot.controller_factory'] = $app->protect(function (Application $app, $controllerName, $methodName, $separator) {
         return $controllerName . $separator . $methodName;
     });
     $app['annot.controllerNamespace'] = '';
 }

 /**
  * Registers new resource creator object
  *
  * @param string  $name
  * @param Closure $resourceFactory
  *
  * @return void
  * @throws DependencyException
  */
 public function registerResourceFactory($name, Closure $resourceFactory)
 {
     $key = $this->diKeys['resource'] . $name;
     if ($this->container->offsetExists($key)) {
         throw new DependencyException("Can't register resource factory with {$name}, because it's already exists");
     }
     $this->container[$key] = $resourceFactory;
 }

 /**
  * @param Container $container the dependency injection container.
  */
 public function register(Container $container)
 {
     if (!$container->offsetExists('quota.targets')) {
         $container['quota.targets'] = [];
     }
     $container['quota'] = function ($container) {
         return new QuotaCell($container['quota.targets']);
     };
 }

 /**
  * {@inheritDoc}
  * @throws ReferenceException
  */
 public function resolveService($arg, Container $container, $alias = "")
 {
     if (!is_string($alias)) {
         $alias = "";
     }
     if ($arg[0] == ContainerBuilder::SERVICE_CHAR) {
         $originalName = substr($arg, 1);
         $name = $this->aliasThisKey($originalName, $alias);
         // check if the service exists
         if (!$container->offsetExists($name)) {
             $name = $originalName;
             if (!$container->offsetExists($name)) {
                 throw new ReferenceException(sprintf("Tried to inject the service '%s', but it doesn't exist", $name));
             }
         }
         $arg = $container[$name];
     }
     return $arg;
 }

 public function register(Container $pimple)
 {
     if ($pimple->offsetExists('facade.aliases')) {
         $aliases = $pimple->offsetGet('facade.aliases');
     } else {
         $aliases = null;
     }
     $facadeServiceLocator = new ArrayAccessAdapter($pimple);
     FacadeLoader::init($facadeServiceLocator, $aliases);
 }

 /**
  * @param Container $container
  */
 public function register(Container $container)
 {
     $container->register(new ValidatorServiceProvider());
     $container["validator.mapping.class_metadata_factory"] = function () use($container) {
         $reader = new AnnotationReader();
         $loader = new AnnotationLoader($reader);
         $cache = $container->offsetExists("cache.factory") && $container["cache.factory"] instanceof Cache ? new DoctrineCache($container["cache.factory"]) : null;
         return new LazyLoadingMetadataFactory($loader, $cache);
     };
 }

 public function register(Container $container)
 {
     $cid = $this->cid;
     $container[$cid] = $container->factory(function () use($cid, $container) {
         $get = function ($key, $default = null) use($container, $cid) {
             $key = $cid . '.' . $key;
             return $container->offsetExists($key) ? $container->offsetGet($key) : $default;
         };
         $pdo = new Database($get('dsn'), $get('user'), $get('password'), $get('options', []));
         return new Db($pdo);
     });
 }

 public function route()
 {
     if ($this->container->offsetExists('controller')) {
         $controller = $this->container['controller'];
         $controller->executeMethod();
         unset($controller);
         //Destroy all the objects
     } else {
         $view = new View\ViewNotFoundHtml($this->container['cms'], $this->container['request']->language);
         $view->renderNotFound();
     }
 }

 public function get($serviceName, $resolveTags = true)
 {
     if (!$this->container instanceof Container) {
         throw new ConfigException("No Container has been set on the ServiceLocator");
     }
     if (!is_string($serviceName)) {
         throw new \InvalidArgumentException("Service name must be a string, received " . gettype($serviceName));
     }
     if (!$this->container->offsetExists($serviceName)) {
         throw new ReferenceException("The key '{$serviceName}' is not registered in this Container");
     }
     $service = $this->container[$serviceName];
     // resolve tags if required
     if ($service instanceof TagCollection && $resolveTags) {
         $services = $service->getServices();
         $service = [];
         foreach ($services as $key => $taggedService) {
             $service[$key] = $this->get($taggedService, false);
         }
     }
     return $service;
 }

 /**
  * @param string $abstract
  * @param array $parameters
  * @return mixed
  * @throws ContainerException
  */
 public function make($abstract, $parameters = [])
 {
     $abstract = $this->getAlias($abstract);
     $normalAbstract = $this->normalize($abstract);
     if ($this->container->offsetExists($normalAbstract)) {
         return $this->container->offsetGet($normalAbstract);
     }
     if (!class_exists($abstract)) {
         throw new ContainerException("Class {$abstract} does not exist");
     }
     $reflector = new \ReflectionClass($abstract);
     if (!$reflector->isInstantiable()) {
         throw new ContainerException("Can't instantiate this");
     }
     $constructor = $reflector->getConstructor();
     if (is_null($constructor)) {
         return new $abstract();
     }
     $parameters = $constructor->getParameters();
     $dependencies = $this->getDependencies($parameters);
     $builder = $reflector->newInstanceArgs($dependencies);
     $this->instance($normalAbstract, $builder);
     return $this->container->offsetGet($normalAbstract);
 }

 public function register(Container $api)
 {
     $api->extend('blimp.extend', function ($status, $api) {
         if ($status) {
             $api['security.oauth.grant.urn:blimp:accounts:google'] = function () {
                 return new Google();
             };
             if ($api->offsetExists('config.root')) {
                 $api->extend('config.root', function ($root, $api) {
                     $tb = new TreeBuilder();
                     $rootNode = $tb->root('google');
                     $rootNode->children()->scalarNode('client_id')->cannotBeEmpty()->end()->scalarNode('client_secret')->cannotBeEmpty()->end()->scalarNode('scope')->defaultValue('email https://www.googleapis.com/auth/plus.login')->end()->scalarNode('fields')->defaultValue('id,name,link,gender,email,picture')->end()->end();
                     $root->append($rootNode);
                     return $root;
                 });
             }
         }
         return $status;
     });
 }