protected function Container::createService in Drupal 8

Same name and namespace in other branches

9 core/lib/Drupal/Component/DependencyInjection/Container.php \Drupal\Component\DependencyInjection\Container::createService()

Creates a service from a service definition.

Parameters

array $definition: The service definition to create a service from.

string $id: The service identifier, necessary so it can be shared if its public.

Return value

object The service described by the service definition.

Throws

\Symfony\Component\DependencyInjection\Exception\RuntimeException Thrown when the service is a synthetic service.

\Symfony\Component\DependencyInjection\Exception\InvalidArgumentException Thrown when the configurator callable in $definition['configurator'] is not actually a callable.

\ReflectionException Thrown when the service class takes more than 10 parameters to construct, and cannot be instantiated.

2 calls to Container::createService()

Container::get in core/lib/Drupal/Component/DependencyInjection/Container.php: Gets a service.
Container::resolveServicesAndParameters in core/lib/Drupal/Component/DependencyInjection/Container.php: Resolves arguments that represent services or variables to the real values.

1 method overrides Container::createService()

PhpArrayContainer::createService in core/lib/Drupal/Component/DependencyInjection/PhpArrayContainer.php: Creates a service from a service definition.

File

core/lib/Drupal/Component/DependencyInjection/Container.php, line 227

Class

Container: Provides a container optimized for Drupal's needs.

Namespace

Drupal\Component\DependencyInjection

Code

protected function createService(array $definition, $id) {
  if (isset($definition['synthetic']) && $definition['synthetic'] === TRUE) {
    throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The service container does not know how to construct this service. The service will need to be set before it is first used.', $id));
  }
  $arguments = [];
  if (isset($definition['arguments'])) {
    $arguments = $definition['arguments'];
    if ($arguments instanceof \stdClass) {
      $arguments = $this
        ->resolveServicesAndParameters($arguments);
    }
  }
  if (isset($definition['file'])) {
    $file = $this->frozen ? $definition['file'] : current($this
      ->resolveServicesAndParameters([
      $definition['file'],
    ]));
    require_once $file;
  }
  if (isset($definition['factory'])) {
    $factory = $definition['factory'];
    if (is_array($factory)) {
      $factory = $this
        ->resolveServicesAndParameters([
        $factory[0],
        $factory[1],
      ]);
    }
    elseif (!is_string($factory)) {
      throw new RuntimeException(sprintf('Cannot create service "%s" because of invalid factory', $id));
    }
    $service = call_user_func_array($factory, $arguments);
  }
  else {
    $class = $this->frozen ? $definition['class'] : current($this
      ->resolveServicesAndParameters([
      $definition['class'],
    ]));
    $service = new $class(...$arguments);
  }
  if (!isset($definition['shared']) || $definition['shared'] !== FALSE) {
    $this->services[$id] = $service;
  }
  if (isset($definition['calls'])) {
    foreach ($definition['calls'] as $call) {
      $method = $call[0];
      $arguments = [];
      if (!empty($call[1])) {
        $arguments = $call[1];
        if ($arguments instanceof \stdClass) {
          $arguments = $this
            ->resolveServicesAndParameters($arguments);
        }
      }
      call_user_func_array([
        $service,
        $method,
      ], $arguments);
    }
  }
  if (isset($definition['properties'])) {
    if ($definition['properties'] instanceof \stdClass) {
      $definition['properties'] = $this
        ->resolveServicesAndParameters($definition['properties']);
    }
    foreach ($definition['properties'] as $key => $value) {
      $service->{$key} = $value;
    }
  }
  if (isset($definition['configurator'])) {
    $callable = $definition['configurator'];
    if (is_array($callable)) {
      $callable = $this
        ->resolveServicesAndParameters($callable);
    }
    if (!is_callable($callable)) {
      throw new InvalidArgumentException(sprintf('The configurator for class "%s" is not a callable.', get_class($service)));
    }
    call_user_func($callable, $service);
  }
  return $service;
}

You are here