DoctrineCollector::getIndexes() - Code Metrics - sonata-project/SonataEasyExtendsBundle - Measure and Improve Code Quality continuously with Scrutinizer

DoctrineCollector::getIndexes() A
last analyzed 2020-03-15 02:05 UTC

↳ Parent: DoctrineCollector

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\EasyExtendsBundle\Mapper;

class DoctrineCollector
{
    /**
     * @var array
     */
    protected $associations;

    /**
     * @var array
     */
    protected $indexes;

    /**
     * @var array
     */
    protected $uniques;

    /**
     * @var array
     */
    protected $discriminators;

    /**
     * @var array
     */
    protected $discriminatorColumns;

    /**
     * @var array
     */
    protected $inheritanceTypes;

    /**
     * @var array
     */
    protected $overrides;

    /**
     * @var DoctrineCollector|null
     */
    private static $instance;

    public function __construct()
    {
        $this->initialize();
    }

    /**
     * @return DoctrineCollector
     */
    public static function getInstance(): self
    {
        if (null === self::$instance) {
            self::$instance = new self();
        }

        return self::$instance;
    }

    /**
     * Add a discriminator to a class.
     *
     * @param string $class              The Class
     * @param string $key                Key is the database value and values are the classes
     * @param string $discriminatorClass The mapped class
     */
    public function addDiscriminator(string $class, string $key, string $discriminatorClass): void
    {
        if (!isset($this->discriminators[$class])) {
            $this->discriminators[$class] = [];
        }

        if (!isset($this->discriminators[$class][$key])) {
            $this->discriminators[$class][$key] = $discriminatorClass;
        }
    }

    /**
     * Add the Discriminator Column.
     */
    public function addDiscriminatorColumn(string $class, array $columnDef): void
    {
        if (!isset($this->discriminatorColumns[$class])) {
            $this->discriminatorColumns[$class] = $columnDef;
        }
    }

    public function addInheritanceType(string $class, string $type): void
    {
        if (!isset($this->inheritanceTypes[$class])) {
            $this->inheritanceTypes[$class] = $type;
        }
    }

    public function addAssociation(string $class, string $type, array $options): void
    {
        if (!isset($this->associations[$class])) {
            $this->associations[$class] = [];
        }

        if (!isset($this->associations[$class][$type])) {
            $this->associations[$class][$type] = [];
        }

        $this->associations[$class][$type][] = $options;
    }

    public function addIndex(string $class, string $name, array $columns): void
    {
        if (!isset($this->indexes[$class])) {
            $this->indexes[$class] = [];
        }

        if (isset($this->indexes[$class][$name])) {
            return;
        }

        $this->indexes[$class][$name] = $columns;
    }

    public function addUnique(string $class, string $name, array $columns): void
    {
        if (!isset($this->indexes[$class])) {
            $this->uniques[$class] = [];
        }

        if (isset($this->uniques[$class][$name])) {
            return;
        }

        $this->uniques[$class][$name] = $columns;
    }

    /**
     * Adds new override.
     */
    final public function addOverride(string $class, string $type, array $options): void
    {
        if (!isset($this->overrides[$class])) {
            $this->overrides[$class] = [];
        }

        if (!isset($this->overrides[$class][$type])) {
            $this->overrides[$class][$type] = [];
        }

        $this->overrides[$class][$type][] = $options;
    }

    public function getAssociations(): array
    {
        return $this->associations;
    }

    public function getDiscriminators(): array
    {
        return $this->discriminators;
    }

    public function getDiscriminatorColumns(): array
    {
        return $this->discriminatorColumns;
    }

    public function getInheritanceTypes(): array
    {
        return $this->inheritanceTypes;
    }

    public function getIndexes(): array
    {
        return $this->indexes;
    }

    public function getUniques(): array
    {
        return $this->uniques;
    }

    /**
     * Get all overrides.
     */
    final public function getOverrides(): array
    {
        return $this->overrides;
    }

    public function clear(): void
    {
        $this->initialize();
    }

    private function initialize(): void
    {
        $this->associations = [];
        $this->indexes = [];
        $this->uniques = [];
        $this->discriminatorColumns = [];
        $this->inheritanceTypes = [];
        $this->discriminators = [];
        $this->overrides = [];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\EasyExtendsBundle\Mapper;
15
16			class DoctrineCollector
17			{
18			/**
19			* @var array
20			*/
21			protected $associations;
22
23			/**
24			* @var array
25			*/
26			protected $indexes;
27
28			/**
29			* @var array
30			*/
31			protected $uniques;
32
33			/**
34			* @var array
35			*/
36			protected $discriminators;
37
38			/**
39			* @var array
40			*/
41			protected $discriminatorColumns;
42
43			/**
44			* @var array
45			*/
46			protected $inheritanceTypes;
47
48			/**
49			* @var array
50			*/
51			protected $overrides;
52
53			/**
54			* @var DoctrineCollector\|null
55			*/
56			private static $instance;
57
58			public function __construct()
59			{
60			$this->initialize();
61			}
62
63			/**
64			* @return DoctrineCollector
65			*/
66			public static function getInstance(): self
67			{
68			if (null === self::$instance) {
69			self::$instance = new self();
70			}
71
72			return self::$instance;
73			}
74
75			/**
76			* Add a discriminator to a class.
77			*
78			* @param string $class The Class
79			* @param string $key Key is the database value and values are the classes
80			* @param string $discriminatorClass The mapped class
81			*/
82			public function addDiscriminator(string $class, string $key, string $discriminatorClass): void
83			{
84			if (!isset($this->discriminators[$class])) {
85			$this->discriminators[$class] = [];
86			}
87
88			if (!isset($this->discriminators[$class][$key])) {
89			$this->discriminators[$class][$key] = $discriminatorClass;
90			}
91			}
92
93			/**
94			* Add the Discriminator Column.
95			*/
96			public function addDiscriminatorColumn(string $class, array $columnDef): void
97			{
98			if (!isset($this->discriminatorColumns[$class])) {
99			$this->discriminatorColumns[$class] = $columnDef;
100			}
101			}
102
103			public function addInheritanceType(string $class, string $type): void
104			{
105			if (!isset($this->inheritanceTypes[$class])) {
106			$this->inheritanceTypes[$class] = $type;
107			}
108			}
109
110			public function addAssociation(string $class, string $type, array $options): void
111			{
112			if (!isset($this->associations[$class])) {
113			$this->associations[$class] = [];
114			}
115
116			if (!isset($this->associations[$class][$type])) {
117			$this->associations[$class][$type] = [];
118			}
119
120			$this->associations[$class][$type][] = $options;
121			}
122
123			public function addIndex(string $class, string $name, array $columns): void
124			{
125			if (!isset($this->indexes[$class])) {
126			$this->indexes[$class] = [];
127			}
128
129			if (isset($this->indexes[$class][$name])) {
130			return;
131			}
132
133			$this->indexes[$class][$name] = $columns;
134			}
135
136			public function addUnique(string $class, string $name, array $columns): void
137			{
138			if (!isset($this->indexes[$class])) {
139			$this->uniques[$class] = [];
140			}
141
142			if (isset($this->uniques[$class][$name])) {
143			return;
144			}
145
146			$this->uniques[$class][$name] = $columns;
147			}
148
149			/**
150			* Adds new override.
151			*/
152			final public function addOverride(string $class, string $type, array $options): void
153			{
154			if (!isset($this->overrides[$class])) {
155			$this->overrides[$class] = [];
156			}
157
158			if (!isset($this->overrides[$class][$type])) {
159			$this->overrides[$class][$type] = [];
160			}
161
162			$this->overrides[$class][$type][] = $options;
163			}
164
165			public function getAssociations(): array
166			{
167			return $this->associations;
168			}
169
170			public function getDiscriminators(): array
171			{
172			return $this->discriminators;
173			}
174
175			public function getDiscriminatorColumns(): array
176			{
177			return $this->discriminatorColumns;
178			}
179
180			public function getInheritanceTypes(): array
181			{
182			return $this->inheritanceTypes;
183			}
184
185			public function getIndexes(): array
186			{
187			return $this->indexes;
188			}
189
190			public function getUniques(): array
191			{
192			return $this->uniques;
193			}
194
195			/**
196			* Get all overrides.
197			*/
198			final public function getOverrides(): array
199			{
200			return $this->overrides;
201			}
202
203			public function clear(): void
204			{
205			$this->initialize();
206			}
207
208			private function initialize(): void
209			{
210			$this->associations = [];
211			$this->indexes = [];
212			$this->uniques = [];
213			$this->discriminatorColumns = [];
214			$this->inheritanceTypes = [];
215			$this->discriminators = [];
216			$this->overrides = [];
217			}
218			}
219

sonata-project / SonataEasyExtendsBundle

DoctrineCollector::getIndexes() A last analyzed 2020-03-15 02:05 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DoctrineCollector::getIndexes() A
last analyzed 2020-03-15 02:05 UTC