DefinitionAggregate::resolve() - Code Metrics - Inspection of "3.x" - thephpleague/container - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#126)

by Phil

created 2017-04-01 20:13 UTC

DefinitionAggregate::resolve() A

↳ Parent: DefinitionAggregate

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	5
nc	3
nop	3

<?php declare(strict_types=1);

namespace League\Container\Definition;

use Generator;
use League\Container\Argument\RawArgument;
use League\Container\ContainerAwareTrait;
use League\Container\Exception\NotFoundException;

class DefinitionAggregate implements DefinitionAggregateInterface
{
    use ContainerAwareTrait;

    /**
     * @var \League\Container\Definition\DefinitionInterface[]
     */
    protected $definitions = [];

    /**
     * {@inheritdoc}
     */
    public function add(string $id, $definition, bool $shared = false): DefinitionInterface
    {
        if (! $definition instanceof DefinitionInterface) {
            $definition = (new Definition($id, $definition));
        }

        $this->definitions[] = $definition
            ->setContainer($this->getContainer())
            ->setAlias($id)
            ->setShared($shared)
        ;

        return $definition;
    }

    /**
     * {@inheritdoc}
     */
    public function resolve(string $id, array $args = [], bool $new = false)
    {
        foreach ($this->getIterator() as $definition) {
            if ($id === $definition->getAlias()) {
                return $definition->resolve($args, $new);
            }
        }

        throw new NotFoundException(sprintf('Alias (%s) is not being handled by the container', $id));
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator(): Generator
    {
        $count = count($this->definitions);

        for ($i = 0; $i < $count; $i++) {
            yield $this->definitions[$i];
        }
    }
}


1			<?php declare(strict_types=1);
2
3			namespace League\Container\Definition;
4
5			use Generator;
6			use League\Container\Argument\RawArgument;
7			use League\Container\ContainerAwareTrait;
8			use League\Container\Exception\NotFoundException;
9
10			class DefinitionAggregate implements DefinitionAggregateInterface
11			{
12			use ContainerAwareTrait;
13
14			/**
15			* @var \League\Container\Definition\DefinitionInterface[]
16			*/
17			protected $definitions = [];
18
19			/**
20			* {@inheritdoc}
21			*/
22			public function add(string $id, $definition, bool $shared = false): DefinitionInterface
23			{
24			if (! $definition instanceof DefinitionInterface) {
25			$definition = (new Definition($id, $definition));
26			}
27
28			$this->definitions[] = $definition
29			->setContainer($this->getContainer())
30			->setAlias($id)
31			->setShared($shared)
32			;
33
34			return $definition;
35			}
36
37			/**
38			* {@inheritdoc}
39			*/
40			public function resolve(string $id, array $args = [], bool $new = false)
41			{
42			foreach ($this->getIterator() as $definition) {
43			if ($id === $definition->getAlias()) {
44			return $definition->resolve($args, $new);
45			}
46			}
47
48			throw new NotFoundException(sprintf('Alias (%s) is not being handled by the container', $id));
49			}
50
51			/**
52			* {@inheritdoc}
53			*/
54			public function getIterator(): Generator
55			{
56			$count = count($this->definitions);
57
58			for ($i = 0; $i < $count; $i++) {
59			yield $this->definitions[$i];
60			}
61			}
62			}
63

thephpleague / container

Pull Request — master (#126)

DefinitionAggregate::resolve() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like