PHP Pimple::offsetGet方法代碼示例

 /**
  * {@inheritdoc}
  */
 public function offsetGet($id)
 {
     if (!in_array($id, $this->serviceWhiteList)) {
         throw new \LogicException(sprintf('You cannot retrieve services until the app has been booted. Attempting to access %s', $id));
     }
     return $this->container->offsetGet($id);
 }

 public function it_normalizes_expressions($parser, \Pimple $container)
 {
     $container->offsetExists('_normalize')->willReturn(true);
     $container->offsetGet('_normalize')->willReturn(array('foo' => 'bar'));
     $parser->evaluate('foo', array('foo' => 'bar'))->willReturn('bar')->shouldBeCalled();
     $this->normalize('?foo', $container)->shouldReturn('bar');
 }

 public function it_creates_a_array_parameter_and_merges_existing_data(Parameter $parameterConf, \Pimple $container)
 {
     $parameterConf->getParameterName()->willReturn('db.options');
     $parameterConf->getParameterValue()->willReturn(array('host' => 'example.org'));
     $parameterConf->getMergeStrategy(Argument::type('array'))->willReturn('array_replace_recursive');
     $parameterConf->mergeExisting()->willReturn(true);
     $container->offsetExists('db.options')->willReturn(true);
     $container->offsetGet('db.options')->willReturn(array('host' => 'localhost', 'user' => 'root', 'password' => 'test'));
     $container->offsetSet('db.options', array('host' => 'example.org', 'user' => 'root', 'password' => 'test'))->shouldBeCalled();
     $container = $this->create($parameterConf, $container);
 }

 /**
  * @param \Pimple $app
  *
  * @throws \Doctrine\DBAL\DBALException
  *
  * @api
  *
  * @quality:method [B]
  */
 public function setup(\Pimple $app)
 {
     if (!$app->offsetExists('config') || !isset($app->offsetGet('config')['doctrine'])) {
         return;
     }
     $config = $app->offsetGet('config');
     ConfigResolver::resolve((array) $config['doctrine:dbal']);
     $app['connections'] = $app::share(function () use($config) {
         $connections = new \Pimple();
         foreach ((array) $config['doctrine:dbal:connections'] as $id => $params) {
             $connections->offsetSet($id, DriverManager::getConnection($params));
         }
         return $connections;
     });
     $app['connection'] = $app::share(function (\Pimple $app) use($config) {
         $ids = $app['connections']->keys();
         $default = $config['doctrine:dbal:default_connection'] ?: current($ids);
         return $app['connections'][$default];
     });
 }

 public function get($id)
 {
     try {
         return parent::offsetGet($id);
     } catch (\Exception $e) {
         if (extension_loaded('xdebug')) {
             throw new DiException(sprintf('Service error "%s" in file "%s" on line %d >> "%s".', $id, xdebug_call_file(), xdebug_call_line(), $e->getMessage()));
         } else {
             throw new DiException(sprintf('Service error "%s" >> "%s"', $id, $e->getMessage()));
         }
     }
 }

 /**
  * @param \Pimple $app
  *
  * @throws \InvalidArgumentException
  *
  * @api
  *
  * @quality:method [B]
  */
 public function setup(\Pimple $app)
 {
     if (!$app->offsetExists('config') || !isset($app->offsetGet('config')['monolog'])) {
         return;
     }
     $config = $app->offsetGet('config');
     $app['loggers'] = $app::share(function (\Pimple $app) use($config) {
         return new LoggerLocator((array) $config['monolog'], $app['app.name']);
     });
     $app['logger'] = $app::share(function (\Pimple $app) {
         return $app['loggers']->getDefaultChannel();
     });
     $app['monolog.bridge'] = $app::share(function (\Pimple $app) {
         return function (OutputInterface $output) use($app) {
             if (class_exists('Symfony\\Bridge\\Monolog\\Handler\\ConsoleHandler') && interface_exists('Symfony\\Component\\EventDispatcher\\EventSubscriberInterface')) {
                 $consoleHandler = new ConsoleHandler($output);
                 /** @var \Monolog\Logger $logger */
                 foreach ($app['loggers'] as $logger) {
                     $logger->pushHandler($consoleHandler);
                 }
             }
         };
     });
 }

 public function offsetGet($id)
 {
     if (!$this->offsetExists($id)) {
         $this[$id] = function ($c) use($id) {
             $arr = array('php', 'ini', 'yml', 'json', 'cache');
             $configDir = $c['configDir']();
             foreach ($arr as $v) {
                 $file = $configDir . "/" . $id . "." . $v;
                 if (file_exists($file)) {
                     break;
                 } else {
                     $file = null;
                 }
             }
             \Fobia\Debug\Log::debug(">> autoload config", array($id, $file));
             if (!$file) {
                 trigger_error("Нет автозагрузочной секции конфигурации '{$id}'" . "/{$file}", E_USER_ERROR);
                 return;
             }
             return Utils::loadConfig($file);
         };
     }
     return parent::offsetGet($id);
 }

 /**
  * @inheritdoc
  */
 public function offsetGet($id)
 {
     $value = parent::offsetGet($id);
     return is_string($value) ? $this->resolveString($value) : $value;
 }

 public function it_can_normalize_array_access_style(\Pimple $container)
 {
     $container->offsetExists('foo')->willReturn(true);
     $container->offsetGet('foo')->willReturn(array('bar' => 'Hello World'));
     $this->normalize('%foo..bar%', $container)->shouldBe('Hello World');
 }

 public function __invoke()
 {
     return $this->pimple->offsetGet($this->serviceId);
 }

 function it_delegates_get(\Pimple $pimple)
 {
     $pimple->offsetGet('foo')->shouldBeCalled();
     $this->get('foo');
 }

 /**
  * Gets a service by id.
  *
  * @param string $id The service id
  *
  * @return object The service
  */
 public static function get($id)
 {
     return self::$pimple->offsetGet($id);
 }

 /**
  * Gets a parameter or an object, first from Pimple, then from the fallback container if it is set.
  *
  * @param string $id The unique identifier for the parameter or object
  *
  * @return mixed The value of the parameter or an object
  *
  * @throws PimpleNotFoundException if the identifier is not defined
  */
 public function offsetGet($id)
 {
     if (!$this->fallbackContainer || $this->mode == self::MODE_STANDARD_COMPLIANT) {
         try {
             return parent::offsetGet($id);
         } catch (\InvalidArgumentException $e) {
             // To respect container-interop, let's wrap the exception.
             throw new PimpleNotFoundException($e->getMessage(), $e->getCode(), $e);
         }
     } elseif ($this->mode == self::MODE_ACT_AS_MASTER) {
         if ($this->nbLoops != 0) {
             if (!array_key_exists($id, $this->values)) {
                 throw new PimpleNotFoundException(sprintf('Identifier "%s" is not defined.', $id));
             }
             $isFactory = is_object($this->values[$id]) && method_exists($this->values[$id], '__invoke');
             return $isFactory ? $this->values[$id]($this->wrappedFallbackContainer) : $this->values[$id];
         } else {
             $this->nbLoops++;
             $instance = $this->fallbackContainer->get($id);
             $this->nbLoops--;
             return $instance;
         }
     } else {
         throw new \Exception("Invalid mode set");
     }
 }

 /**
  * Sets a parameter.
  *
  * @param string $name  The parameter name
  * @param mixed  $value The parameter value
  *
  * @api
  */
 public function setParameter($name, $value)
 {
     $config = $this->pimple->offsetGet('config');
     $config[$name] = $value;
     $this->pimple->offsetSet('config', $config);
 }

 public function offsetGet($id)
 {
     $this->assertSetUpHasBeenCalled();
     return parent::offsetGet($id);
 }