PHP Container::findByType方法代码示例

 /**
  * Creates new presenter instance.
  *
  * @param  string presenter class name
  * @return Application\IPresenter
  */
 public function createPresenter($class)
 {
     $callInjects = $this->alwaysCallInjects;
     $services = array_keys($this->container->findByTag('nette.presenter'), $class);
     if (count($services) > 1) {
         throw new Application\InvalidPresenterException("Multiple services of type {$class} found: " . implode(', ', $services) . '.');
     } elseif (count($services)) {
         $presenter = $this->container->createService($services[0]);
         $callInjects = FALSE;
     } elseif (count($services = $this->container->findByType($class)) === 1) {
         $presenter = $this->container->createService($services[0]);
     } else {
         $presenter = $this->container->createInstance($class);
         $callInjects = TRUE;
     }
     if (!$presenter instanceof Application\IPresenter) {
         throw new UnexpectedValueException("Unable to create create presenter, returned value is not Nette\\Application\\IPresenter type.");
     }
     if ($callInjects) {
         $this->container->callInjects($presenter);
     }
     if ($presenter instanceof Application\UI\Presenter && $presenter->invalidLinkMode === NULL) {
         $presenter->invalidLinkMode = $this->invalidLinkMode;
     }
     return $presenter;
 }

 public function __construct(Container $container)
 {
     $this->connections = array_keys($container->findByTag(OrmExtension::TAG_CONNECTION));
     $this->defaultConnection = $container->findByType('Doctrine\\DBAL\\Connection');
     $this->managers = array_keys($container->findByTag(OrmExtension::TAG_ENTITY_MANAGER));
     $this->defaultManager = $container->findByType('Doctrine\\ORM\\EntityManager');
     $this->container = $container;
 }

 /**
  * @param string $type
  * @return string|bool
  */
 private function findByTypeForFactory($type)
 {
     if (method_exists($this->autowireComponentFactoriesLocator, 'findByType')) {
         $found = $this->autowireComponentFactoriesLocator->findByType($type);
         return reset($found);
     }
     $type = ltrim(strtolower($type), '\\');
     return !empty($this->autowireComponentFactoriesLocator->classes[$type]) ? $this->autowireComponentFactoriesLocator->classes[$type] : FALSE;
 }

 public function actionView(int $id = NULL)
 {
     $repositories = array_combine(array_map('crc32', array_map('get_class', $repositories = array_map([$this->container, 'getService'], $this->container->findByType(Nextras\Orm\Repository\IRepository::class)))), $repositories);
     if ($id === NULL) {
         $this->generateIndex(array_filter($repositories, [$this, 'getLinkProperties']));
     } elseif (isset($repositories[$id])) {
         $this->generateUrlSet($this->repository = $repositories[$id]);
     } else {
         $this->error();
     }
 }

 /**
  * Creates new presenter instance.
  * @param  string  presenter name
  * @return IPresenter
  */
 public function createPresenter($name)
 {
     $class = $this->getPresenterClass($name);
     if (count($services = $this->container->findByType($class)) === 1) {
         $presenter = $this->container->createService($services[0]);
     } else {
         $presenter = $this->container->createInstance($class);
     }
     $this->container->callInjects($presenter);
     if ($presenter instanceof UI\Presenter && $presenter->invalidLinkMode === NULL) {
         $presenter->invalidLinkMode = $this->container->parameters['debugMode'] ? UI\Presenter::INVALID_LINK_WARNING : UI\Presenter::INVALID_LINK_SILENT;
     }
     return $presenter;
 }

 /**
  * Create a new repository instance for an entity class.
  *
  * @param \Doctrine\ORM\EntityManagerInterface $entityManager The EntityManager instance.
  * @param Doctrine\ORM\Mapping\ClassMetadata $metadata
  * @return Doctrine\Common\Persistence\ObjectRepository
  */
 private function createRepository(EntityManagerInterface $entityManager, Doctrine\ORM\Mapping\ClassMetadata $metadata)
 {
     $defaultRepository = $entityManager->getConfiguration()->getDefaultRepositoryClassName();
     $repositoryClassName = $metadata->customRepositoryClassName ?: $defaultRepository;
     if ($repositoryClassName === $defaultRepository) {
         return new $repositoryClassName($entityManager, $metadata);
     } elseif (!($services = $this->serviceLocator->findByType($repositoryClassName))) {
         // todo: solve me in future, maybe just throw an exception?
         return new $repositoryClassName($entityManager, $metadata);
     } elseif (count($services) > 1) {
         // todo: solve me in future, maybe just throw an exception?
         return new $repositoryClassName($entityManager, $metadata);
     } else {
         return $this->serviceLocator->createService($services[0], array('entityManager' => $entityManager, 'metadata' => $metadata));
     }
 }

 /**
  * Registers 'addPaymentButtons' & 'addPaymentButton' methods to form using DI container
  *
  * @param Container $container
  */
 public static function registerAddPaymentButtonsUsingDependencyContainer(Container $container)
 {
     $binder = $container->getByType(Binder::class);
     $services = $container->findByType(AbstractPaymentService::class);
     foreach ($services as $service) {
         self::registerAddPaymentButtons($binder, $container->getService($service));
     }
 }

 /**
  * @param string $type
  * @param Container $container
  * @return object[]
  */
 public static function findServicesOfType($type, Container $container)
 {
     $services = array();
     foreach ($container->findByType($type) as $name) {
         $services[] = $container->getService($name);
     }
     return $services;
 }

 public function __construct(Container $container)
 {
     $this->container = $container;
     $listeners = $this->container->findByType('\\Phoenix\\Events\\IEventListener');
     foreach ($listeners as $class) {
         $reflection = ClassType::from($container->getService($class));
         foreach ($reflection->getMethods() as $method) {
             if ($method->hasAnnotation(self::ANNOTATION_EVENT_LISTENER)) {
                 $event = (string) $method->getAnnotation(self::ANNOTATION_EVENT_LISTENER);
                 if (!isset($this->eventListeners[$event])) {
                     $this->eventListeners[$event] = [];
                 }
                 $this->eventListeners[$event][] = new EventListenerWrapper($container->getService($class), $method);
             }
         }
     }
 }

 /**
  * @param ActiveRow $activeRow
  * @param $tableName
  * @throws InvalidStateException
  * @return HyperRow
  */
 public function createRow(ActiveRow $activeRow, $tableName)
 {
     $className = Helpers::substituteClassWildcard($this->rowMapping, $tableName);
     $baseClass = HyperRow::class;
     if (!class_exists($className) || !is_subclass_of($className, $baseClass)) {
         throw new InvalidStateException("HyperRow class {$className} does not exist or does not extend {$baseClass}.");
     }
     $names = $this->container->findByType($className);
     if (count($names) > 1) {
         throw new InvalidStateException("Multiple services of type {$className} found: " . implode(', ', $names) . '.');
     } elseif (count($names) == 0) {
         $inst = $this->container->createInstance($className);
     } else {
         $name = array_shift($names);
         $inst = $this->container->createService($name);
     }
     /** @var HyperRow $inst */
     $inst->setFactory($this);
     $inst->setActiveRow($activeRow);
     return $inst;
 }

 public static function createConfigFromNetteDatabase(Container $container, $defaults = [])
 {
     $config = $defaults;
     $config['environments']['default_database'] = 'default';
     foreach ($container->findByType(Connection::class) as $connectionServiceName) {
         $parts = explode(".", $connectionServiceName);
         $environment = $parts[1];
         /** @var Connection $connection */
         $connection = $container->getService($connectionServiceName);
         $dbname = self::getDsnValue('dbname', $connection->getDsn());
         $config['environments'][$environment] = ['name' => $dbname, 'connection' => $connection->getPdo()];
     }
     return new Config($config);
 }

 public function __construct(Container $container)
 {
     foreach ($container->findByType(IManager::class) as $name) {
         $this->register($container->getService($name));
     }
 }

 /**
  * @param string $class
  * @return string[]
  */
 public function findByType($class)
 {
     return $this->container->findByType($class);
 }