Service of type FHB\Zoe\Application\Module\Api\Control\ReceivedOrderListControlFactory: Service of type FHB\Zoe\Application\Module\Api\Control\ReceivedOrderListControl: Service of type FHB\Zoe\Domain\CustomerIntegration\Service\ReceivedOrderValidation required by $receivedOrderValidation in ReceivedOrderListControl::__construct() not found. Did you add it to configuration file?

567:                    break;
568:    
569:                } elseif (array_key_exists($paramName, $arguments)) {
570:                    $res[$useName ? $paramName : $num] = $arguments[$paramName];
571:                    unset($arguments[$paramName], $arguments[$num]);
572:    
573:                } elseif (array_key_exists($num, $arguments)) {
574:                    $res[$useName ? $paramName : $num] = $arguments[$num];
575:                    unset($arguments[$num]);
576:    
577:                } elseif (($aw = self::autowireArgument($param, $getter)) !== null) {
578:                    $res[$useName ? $paramName : $num] = $aw;
579:    
580:                } elseif (PHP_VERSION_ID >= 80000) {
581:                    if ($param->isOptional()) {

222:                    break;
223:    
224:                case is_string($entity): // create class
225:                    if (!class_exists($entity)) {
226:                        throw new ServiceCreationException(sprintf("Class '%s' not found.", $entity));
227:                    } elseif ((new ReflectionClass($entity))->isAbstract()) {
228:                        throw new ServiceCreationException(sprintf('Class %s is abstract.', $entity));
229:                    } elseif (($rm = (new ReflectionClass($entity))->getConstructor()) !== null && !$rm->isPublic()) {
230:                        throw new ServiceCreationException(sprintf('Class %s has %s constructor.', $entity, $rm->isProtected() ? 'protected' : 'private'));
231:                    } elseif ($constructor = (new ReflectionClass($entity))->getConstructor()) {
232:                        $arguments = self::autowireArguments($constructor, $arguments, $getter);
233:                        $this->addDependency($constructor);
234:                    } elseif ($arguments) {
235:                        throw new ServiceCreationException(sprintf(
236:                            'Unable to pass arguments, class %s has no constructor.',

216:    
217:    
218:        public function complete(Nette\DI\Resolver $resolver): void
219:        {
220:            $entity = $this->factory->getEntity();
221:            if ($entity instanceof Reference && !$this->factory->arguments && !$this->setup) {
222:                $ref = $resolver->normalizeReference($entity);
223:                $this->setFactory([new Reference(Nette\DI\ContainerBuilder::THIS_CONTAINER), 'getService'], [$ref->getValue()]);
224:            }
225:    
226:            $this->factory = $resolver->completeStatement($this->factory);
227:    
228:            foreach ($this->setup as &$setup) {
229:                if (
230:                    is_string($setup->getEntity())

158:    
159:        public function completeDefinition(Definition $def): void
160:        {
161:            $this->currentService = in_array($def, $this->builder->getDefinitions(), true)
162:                ? $def
163:                : null;
164:            $this->currentServiceType = $def->getType();
165:            $this->currentServiceAllowed = false;
166:    
167:            try {
168:                $def->complete($this);
169:    
170:                $this->addDependency(new \ReflectionClass($def->getType()));
171:    
172:            } catch (\Throwable $e) {

225:                }
226:    
227:                if ($resultDef->getEntity() instanceof Reference && !$resultDef->getFactory()->arguments) {
228:                    $resultDef->setFactory([ // render as $container->createMethod()
229:                        new Reference(Nette\DI\ContainerBuilder::THIS_CONTAINER),
230:                        Nette\DI\Container::getMethodName($resultDef->getEntity()->getValue()),
231:                    ]);
232:                }
233:            }
234:    
235:            $resolver->completeDefinition($resultDef);
236:        }
237:    
238:    
239:        private function completeParameters(Nette\DI\Resolver $resolver): void

158:    
159:        public function completeDefinition(Definition $def): void
160:        {
161:            $this->currentService = in_array($def, $this->builder->getDefinitions(), true)
162:                ? $def
163:                : null;
164:            $this->currentServiceType = $def->getType();
165:            $this->currentServiceAllowed = false;
166:    
167:            try {
168:                $def->complete($this);
169:    
170:                $this->addDependency(new \ReflectionClass($def->getType()));
171:    
172:            } catch (\Throwable $e) {

322:    
323:        public function complete(): void
324:        {
325:            $this->resolve();
326:            foreach ($this->definitions as $def) {
327:                $def->setNotifier(null);
328:            }
329:    
330:            $resolver = new Resolver($this);
331:            foreach ($this->definitions as $def) {
332:                $resolver->completeDefinition($def);
333:            }
334:        }
335:    
336:    

265:    
266:        private function processBeforeCompile(): void
267:        {
268:            $this->builder->resolve();
269:    
270:            foreach ($this->extensions as $extension) {
271:                $extension->beforeCompile();
272:                $this->dependencies->add([(new \ReflectionClass($extension))->getFileName()]);
273:            }
274:    
275:            $this->builder->complete();
276:        }
277:    
278:    
279:        /**

202:                $this->extensions[self::DI]->exportedTypes[$type] = true;
203:            }
204:    
205:            return $this;
206:        }
207:    
208:    
209:        public function compile(): string
210:        {
211:            $this->processExtensions();
212:            $this->processBeforeCompile();
213:            return $this->generateCode();
214:        }
215:    
216:    

109:    
110:            return false;
111:        }
112:    
113:    
114:        /** @return array of (code, file[]) */
115:        protected function generate(string $class, callable $generator): array
116:        {
117:            $compiler = new Compiler;
118:            $compiler->setClassName($class);
119:            $code = $generator(...[&$compiler]) ?: $compiler->compile();
120:            return [
121:                "<?php\n$code",
122:                serialize($compiler->exportDependencies()),
123:            ];

71:                throw new Nette\IOException(sprintf("Unable to create file '%s.lock'. %s", $file, Nette\Utils\Helpers::getLastError()));
72:            } elseif (!@flock($handle, LOCK_EX)) { // @ is escalated to exception
73:                // the lock will automatically be freed when $handle goes out of scope
74:                throw new Nette\IOException(sprintf("Unable to acquire exclusive lock on '%s.lock'. %s", $file, Nette\Utils\Helpers::getLastError()));
75:            }
76:    
77:            if (!is_file($file) || $this->isExpired($file, $updatedMeta)) {
78:                if (isset($updatedMeta)) {
79:                    $toWrite["$file.meta"] = $updatedMeta;
80:                } else {
81:                    [$toWrite[$file], $toWrite["$file.meta"]] = $this->generate($class, $generator);
82:                }
83:    
84:                foreach ($toWrite as $name => $content) {
85:                    if (file_put_contents("$name.tmp", $content) !== strlen($content) || !rename("$name.tmp", $name)) {

'Container_321585854b'

34:    
35:    
36:        /**
37:         * @param  callable  $generator  function (Nette\DI\Compiler $compiler): string|null
38:         * @param  mixed  $key
39:         */
40:        public function load(callable $generator, $key = null): string
41:        {
42:            $class = $this->getClassName($key);
43:            if (!class_exists($class, false)) {
44:                $this->loadFile($class, $generator);
45:            }
46:    
47:            return $class;
48:        }

'Container_321585854b'

264:         */
265:        public function loadContainer(): string
266:        {
267:            $loader = new DI\ContainerLoader(
268:                $this->getCacheDirectory() . '/nette.configurator',
269:                $this->staticParameters['debugMode']
270:            );
271:            return $loader->load(
272:                [$this, 'generateContainer'],
273:                [
274:                    $this->staticParameters,
275:                    array_keys($this->dynamicParameters),
276:                    $this->configs,
277:                    PHP_VERSION_ID - PHP_RELEASE_VERSION, // minor PHP version
278:                    class_exists(ClassLoader::class) ? filemtime((new \ReflectionClass(ClassLoader::class))->getFilename()) : null, // composer update

242:            $this->configs[] = $config;
243:            return $this;
244:        }
245:    
246:    
247:        /**
248:         * Returns system DI container.
249:         */
250:        public function createContainer(): DI\Container
251:        {
252:            $class = $this->loadContainer();
253:            $container = new $class($this->dynamicParameters);
254:            foreach ($this->services as $name => $service) {
255:                $container->addService($name, $service);
256:            }