Gets the service names of the specified type.
| public findByType ( $class ) : string[] | ||
| return | string[] | |
/**
* 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);
}
