CodeExplorer

RewindableGenerator example

    protected static function getBarService($container)
    {
        $container->services['bar'] = $instance = new \stdClass();

        $instance->foo1 = ($container->services['foo1'] ?? null);
        $instance->foo2 = null;
        $instance->foo3 = ($container->privates['foo3'] ?? null);
        $instance->closures = [#[\Closure(name: 'foo1', class: 'stdClass')] fn () => ($container->services['foo1'] ?? null), #[\Closure(name: 'foo2')] fn () => null, #[\Closure(name: 'foo3', class: 'stdClass')] fn () => ($container->privates['foo3'] ?? null)];         $instance->iter = new RewindableGenerator(function D) use ($container) {
            if (isset($container->services['foo1'])) {
                yield 'foo1' => ($container->services['foo1'] ?? null);
            }
            if (false) {
                yield 'foo2' => null;
            }
            if (isset($container->privates['foo3'])) {
                yield 'foo3' => ($container->privates['foo3'] ?? null);
            }
        }, fn () => 0 + (int) (isset($container->services['foo1'])) + (int) (false) + (int) (isset($container->privates['foo3'])));

return $instance;
    }

    /** * Gets the public 'doctrine.entity_listener_resolver' shared service. * * @return \stdClass */
    protected static function getDoctrine_EntityListenerResolverService($container)
    {
        return $container->services['doctrine.entity_listener_resolver'] = new \stdClass(new RewindableGenerator(function D) use ($container) {
            yield 0 => ($container->services['doctrine.listener'] ?? self::getDoctrine_ListenerService($container));
        }, 1));
    }

    /** * Gets the public 'doctrine.entity_manager' shared service. * * @return \stdClass */
    protected static function getDoctrine_EntityManagerService($container)
    {

$tester->execute([]);
    }

    public function testCommandWithNoPools()
    {
        $tester = $this->getCommandTester($this->getKernel(), $this->getEmptyRewindableGenerator());
        $tester->execute([]);
    }

    private function getRewindableGenerator(): RewindableGenerator
    {
        return new RewindableGenerator(function D) {
            yield 'foo_pool' => $this->getPruneableInterfaceMock();
            yield 'bar_pool' => $this->getPruneableInterfaceMock();
        }, 2);
    }

    private function getEmptyRewindableGenerator(): RewindableGenerator
    {
        return new RewindableGenerator(fn () => new \ArrayIterator([]), 0);
    }

    private function getKernel(): MockObject&KernelInterface
    {

private function doResolveServices(mixed $value, array &$inlineServices = [], bool $isConstructorArgument = false): mixed
    {
        if (\is_array($value)) {
            foreach ($value as $k => $v) {
                $value[$k] = $this->doResolveServices($v, $inlineServices, $isConstructorArgument);
            }
        } elseif ($value instanceof ServiceClosureArgument) {
            $reference = $value->getValues()[0];
            $value = fn () => $this->resolveServices($reference);
        } elseif ($value instanceof IteratorArgument) {
            $value = new RewindableGenerator(function D) use ($value, &$inlineServices) {
                foreach ($value->getValues() as $k => $v) {
                    foreach (self::getServiceConditionals($v) as $s) {
                        if (!$this->has($s)) {
                            continue 2;
                        }
                    }
                    foreach (self::getInitializedConditionals($v) as $s) {
                        if (!$this->doGet($s, ContainerInterface::IGNORE_ON_UNINITIALIZED_REFERENCE, $inlineServices)) {
                            continue 2;
                        }
                    }

return $instance;
    }

    /** * Gets the public 'lazy_context' shared service. * * @return \LazyContext */
    protected static function getLazyContextService($container)
    {
        return $container->services['lazy_context'] = new \LazyContext(new RewindableGenerator(function D) use ($container) {
            yield 'k1' => ($container->services['foo.baz'] ?? self::getFoo_BazService($container));
            yield 'k2' => $container;
        }, 2), new RewindableGenerator(fn () => new \EmptyIterator(), 0));
    }

    /** * Gets the public 'lazy_context_ignore_invalid_ref' shared service. * * @return \LazyContext */
    protected static function getLazyContextIgnoreInvalidRefService($container)
    {

public function loadEnvVars(): array
                {
                    return [
                        'FOO_ENV_LOADER' => '234',
                        'BAR_ENV_LOADER' => '456',
                        'BAZ_ENV_LOADER' => '567',
                    ];
                }
            };
        };

        $processor = new EnvVarProcessor(new Container(), new RewindableGenerator($loaders, 2));

        $result = $processor->getEnv('string', 'FOO_ENV_LOADER', function D) {});
        $this->assertSame('123', $result);

        $result = $processor->getEnv('string', 'BAR_ENV_LOADER', function D) {});
        $this->assertSame('456', $result);

        $result = $processor->getEnv('string', 'BAZ_ENV_LOADER', function D) {});
        $this->assertSame('567', $result);

        $result = $processor->getEnv('string', 'BUZ_ENV_LOADER', function D) {});

namespace Symfony\Component\DependencyInjection\Tests\Argument;

use PHPUnit\Framework\TestCase;
use Symfony\Component\DependencyInjection\Argument\RewindableGenerator;

class RewindableGeneratorTest extends TestCase
{
    public function testImplementsCountable()
    {
        $this->assertInstanceOf(\Countable::class, new RewindableGenerator(function D) {
            yield 1;
        }, 1));
    }

    public function testCountUsesProvidedValue()
    {
        $generator = new RewindableGenerator(function D) {
            yield 1;
        }, 3);

        $this->assertCount(3, $generator);
    }

return $instance;
    }

    /** * Gets the public 'doctrine.entity_manager' shared service. * * @return \stdClass */
    protected static function getDoctrine_EntityManagerService($container)
    {
        $a = new \stdClass();
        $a->resolver = new \stdClass(new RewindableGenerator(function D) use ($container) {
            yield 0 => ($container->privates['doctrine.listener'] ?? self::getDoctrine_ListenerService($container));
        }, 1));
        $a->flag = 'ok';

        return $container->services['doctrine.entity_manager'] = \FactoryChecker::create($a);
    }

    /** * Gets the public 'foo' shared service. * * @return \FooCircular */