CodeExplorer

getServiceCall example

$code = '';
        }

        if (isset($this->referenceVariables[$targetId]) || (2 > $callCount && (!$hasSelfRef || !$forConstructor))) {
            return $code;
        }

        $name = $this->getNextVariableName();
        $this->referenceVariables[$targetId] = new Variable($name);

        $reference = ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE >= $behavior ? new Reference($targetId, $behavior) : null;
        $code .= sprintf(" \$%s = %s;\n", $name, $this->getServiceCall($targetId, $reference));

        if (!$hasSelfRef || !$forConstructor) {
            return $code;
        }

        $code .= sprintf(<<<'EOTXT' if (isset($container->%s[%s])) { return $container->%1$s[%2$s]; }

  protected function getMockContainerDefinition() {
    $fake_service = new \stdClass();
    $parameters = [];
    $parameters['some_parameter_class'] = get_class($fake_service);
    $parameters['some_private_config'] = 'really_private_lama';
    $parameters['some_config'] = 'foo';
    $parameters['some_other_config'] = 'lama';
    $parameters['factory_service_class'] = get_class($fake_service);
    // Also test alias resolving.     $parameters['service_from_parameter'] = $this->getServiceCall('service.provider_alias');

    $services = [];
    $services['service_container'] = [
      'class' => '\Drupal\service_container\DependencyInjection\Container',
    ];
    $services['other.service'] = [
      'class' => get_class($fake_service),
    ];

    $services['non_shared_service'] = [
      'class' => get_class($fake_service),

    if (isset($this->aliases[$id])) {
      $id = $this->aliases[$id];
    }
    $definition = $this->container->getDefinition($id);
    if (!$definition->isPublic()) {
      // The ContainerBuilder does not share a private service, but this means a       // new service is instantiated every time. Use a private shared service to       // circumvent the problem.       return $this->getPrivateServiceCall($id, $definition, TRUE);
    }

    return $this->getServiceCall($id, $invalid_behavior);
  }

  /** * Gets a service reference for an ID in a suitable PHP array format. * * @param string $id * The ID of the service to get a reference for. * @param int $invalid_behavior * (optional) The invalid behavior of the service. * * @return string|object * A suitable representation of the service reference. */

return $this->dumper->dump(['parameters' => $parameters], 2);
    }

    /** * Dumps callable to YAML format. */
    private function dumpCallable(mixed $callable): mixed
    {
        if (\is_array($callable)) {
            if ($callable[0] instanceof Reference) {
                $callable = [$this->getServiceCall((string) $callable[0], $callable[0]), $callable[1]];
            } else {
                $callable = [$callable[0], $callable[1]];
            }
        }

        return $callable;
    }

    /** * Dumps the value to YAML format. * * @throws RuntimeException When trying to dump object or resource */

'shared' => FALSE,
      ] + $base_service_definition;

      $service_definitions[] = [
        'lazy' => TRUE,
      ] + $base_service_definition;

      // Test a basic public Reference.       $service_definitions[] = [
        'arguments' => ['foo', new Reference('bar')],
        'arguments_count' => 2,
        'arguments_expected' => static::getCollection(['foo', static::getServiceCall('bar')]),
      ] + $base_service_definition;

      // Test a public reference that should not throw an Exception.       $reference = new Reference('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE);
      $service_definitions[] = [
        'arguments' => [$reference],
        'arguments_count' => 1,
        'arguments_expected' => static::getCollection([static::getServiceCall('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE)]),
      ] + $base_service_definition;

      // Test a private shared service, denoted by having a Reference.