EntityManager::extensionMethod() - Code Metrics - Inspection of "Travis: aliasing of mysql service" - Kdyby/Doctrine - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d88939...76eafd )

by Filip

created 2017-05-15 13:58 UTC

EntityManager::extensionMethod() A

↳ Parent: EntityManager

Complexity

Conditions	3
Paths	4

Size

Total Lines	13
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.4285
c	0
b	0
f	0
cc	3
eloc	9
nc	4
nop	2

<?php

/**
 * This file is part of the Kdyby (http://www.kdyby.org)
 *
 * Copyright (c) 2008 Filip Procházka ([email protected])
 *
 * For the full copyright and license information, please view the file license.txt that was distributed with this source code.
 */

namespace Kdyby\Doctrine;

use Doctrine;
use Doctrine\DBAL\DriverManager;
use Doctrine\ORM\AbstractQuery;
use Doctrine\ORM\ORMException;
use Doctrine\ORM\Query;
use Kdyby;
use Kdyby\Doctrine\QueryObject;
use Kdyby\Doctrine\Tools\NonLockingUniqueInserter;
use Kdyby\Persistence;
use Nette;
use Nette\Utils\ObjectMixin;



/**
 * @author Filip Procházka <[email protected]>
 *
 * @method \Kdyby\Doctrine\Connection getConnection()
 * @method \Kdyby\Doctrine\Configuration getConfiguration()
 * @method \Kdyby\Doctrine\EntityRepository getRepository($entityName)
 */
class EntityManager extends Doctrine\ORM\EntityManager implements Persistence\QueryExecutor, Persistence\Queryable

{

	/**
	 * @var NonLockingUniqueInserter
	 */
	private $nonLockingUniqueInserter;

	/**
	 * @var Diagnostics\Panel
	 */
	private $panel;



	protected function __construct(Doctrine\DBAL\Connection $conn, Doctrine\ORM\Configuration $config, Doctrine\Common\EventManager $eventManager)
	{
		parent::__construct($conn, $config, $eventManager);

		if ($conn instanceof Kdyby\Doctrine\Connection) {
			$conn->bindEntityManager($this);
		}
	}



	/**
	 * @internal
	 * @param Diagnostics\Panel $panel
	 */
	public function bindTracyPanel(Diagnostics\Panel $panel)
	{
		$this->panel = $panel;
	}



	/**
	 * @throws NotSupportedException
	 * @return \Kdyby\Doctrine\QueryBuilder
	 */
	public function createQueryBuilder($alias = NULL, $indexBy = NULL)
	{
		if ($alias !== NULL || $indexBy !== NULL) {
			throw new NotSupportedException('Use EntityRepository for $alias and $indexBy arguments to work.');
		}

		if (($config = $this->getConfiguration()) instanceof Configuration) {
			$class = $config->getQueryBuilderClassName();
			return new $class($this);
		}

		return new QueryBuilder($this);
	}



	/**
	 * {@inheritdoc}
	 * @param string|array $entity
/**
 * @param array $germany
 * @param array $ireland
 */
function finale($germany, $island) {
    return "2:1";
}
	 * @return EntityManager
	 */
	public function clear($entityName = null)
	{
		foreach (is_array($entityName) ? $entityName : (func_get_args() + [0 => NULL]) as $item) {
			parent::clear($item);
		}

		return $this;
	}



	/**
	 * {@inheritdoc}
	 * @param object|array $entity
	 * @return EntityManager
	 */
	public function remove($entity)
	{
		foreach (is_array($entity) ? $entity : func_get_args() as $item) {
			parent::remove($item);
		}

		return $this;
	}



	/**
	 * {@inheritdoc}
	 * @param object|array $entity
	 * @return EntityManager
	 */
	public function persist($entity)
	{
		foreach (is_array($entity) ? $entity : func_get_args() as $item) {
			parent::persist($item);
		}

		return $this;
	}



	/**
	 * {@inheritdoc}
	 * @param object|array $entity
	 * @return EntityManager
	 */
	public function flush($entity = null)
	{
		try {
			parent::flush($entity);

		} catch (\Exception $e) {
			if ($this->panel) {
				$this->panel->markExceptionOwner($this, $e);
			}

			throw $e;
		}

		return $this;
	}



	public function close()
	{
		if ($this->panel) {
			$this->panel->snapshotUnitOfWork($this);
		}

		parent::close();
	}



	/**
	 * Tries to persist the given entity and returns FALSE if an unique
	 * constaint was violated.
	 *
	 * Warning: On success you must NOT use the passed entity further
	 * in your application. Use the returned one instead!
	 *
	 * @param $entity
	 * @throws \Doctrine\DBAL\DBALException
	 * @throws \Exception
	 * @return bool|object
	 */
	public function safePersist($entity)
	{
		if ($this->nonLockingUniqueInserter === NULL) {
			$this->nonLockingUniqueInserter = new NonLockingUniqueInserter($this);
		}

		return $this->nonLockingUniqueInserter->persist($entity);
	}



	/**
	 * @param int $hydrationMode
	 * @return Doctrine\ORM\Internal\Hydration\AbstractHydrator
	 * @throws \Doctrine\ORM\ORMException
	 */
	public function newHydrator($hydrationMode)
	{
		switch ($hydrationMode) {
			case Hydration\HashHydrator::NAME:
				return new Hydration\HashHydrator($this);

			default:
				return parent::newHydrator($hydrationMode);
		}
	}



	/**
	 * Factory method to create EntityManager instances.
	 *
	 * @param \Doctrine\DBAL\Connection|array $conn
	 * @param \Doctrine\ORM\Configuration $config
	 * @param \Doctrine\Common\EventManager $eventManager
	 * @throws \Doctrine\ORM\ORMException
	 * @throws \InvalidArgumentException
	 * @throws \Doctrine\ORM\ORMException
	 * @return EntityManager
	 */
	public static function create($conn, Doctrine\ORM\Configuration $config, Doctrine\Common\EventManager $eventManager = NULL)
	{
		if (!$config->getMetadataDriverImpl()) {
			throw ORMException::missingMappingDriverImpl();
		}

		switch (TRUE) {
			case (is_array($conn)):
				$conn = DriverManager::getConnection(
					$conn, $config, ($eventManager ? : new Doctrine\Common\EventManager())
				);
				break;

			case ($conn instanceof Doctrine\DBAL\Connection):
if ($x instanceof DoesNotExist) {
    // Do something.
}
				if ($eventManager !== NULL && $conn->getEventManager() !== $eventManager) {
					throw ORMException::mismatchedEventManager();
				}
				break;

			default:
				throw new \InvalidArgumentException("Invalid connection");
		}

		return new EntityManager($conn, $config, $conn->getEventManager());
	}



	/****************** Kdyby\Persistence\QueryExecutor *****************/



	/**
	 * @param \Kdyby\Persistence\Query|\Kdyby\Doctrine\QueryObject $queryObject
	 * @param int $hydrationMode
	 * @throws QueryException
	 * @return array|\Kdyby\Doctrine\ResultSet
	 */
	public function fetch(Persistence\Query $queryObject, $hydrationMode = AbstractQuery::HYDRATE_OBJECT)
	{
		try {
			return $queryObject->fetch($this, $hydrationMode);


		} catch (\Exception $e) {
			throw $this->handleQueryException($e, $queryObject);
		}
	}



	/**
	 * @param \Kdyby\Persistence\Query|\Kdyby\Doctrine\QueryObject $queryObject
	 *
	 * @throws InvalidStateException
	 * @throws QueryException
	 * @return object|NULL
	 */
	public function fetchOne(Persistence\Query $queryObject)
	{
		try {
			return $queryObject->fetchOne($this);

		} catch (Doctrine\ORM\NoResultException $e) {

			return NULL;

		} catch (Doctrine\ORM\NonUniqueResultException $e) { // this should never happen!

			throw new InvalidStateException("You have to setup your query calling ->setMaxResult(1).", 0, $e);

		} catch (\Exception $e) {
			throw $this->handleQueryException($e, $queryObject);
		}
	}



	/**
	 * @param \Exception $e
	 * @param \Kdyby\Persistence\Query $queryObject
	 *
	 * @throws \Exception
	 */
	private function handleQueryException(\Exception $e, Persistence\Query $queryObject)
	{
		$lastQuery = $queryObject instanceof QueryObject ? $queryObject->getLastQuery() : NULL;

		return new QueryException($e, $lastQuery, '['.get_class($queryObject).'] '.$e->getMessage());
	}



	/*************************** Nette\Object ***************************/



	/**
	 * Access to reflection.
	 *
	 * @return \Nette\Reflection\ClassType
	 */
	public static function getReflection()
	{
		return new Nette\Reflection\ClassType(get_called_class());
	}



	/**
	 * Call to undefined method.
	 *
	 * @param string $name
	 * @param array $args
	 *
	 * @throws \Nette\MemberAccessException
	 * @return mixed
	 */
	public function __call($name, $args)
	{
		return ObjectMixin::call($this, $name, $args);
	}



	/**
	 * Call to undefined static method.
	 *
	 * @param string $name
	 * @param array $args
	 *
	 * @throws \Nette\MemberAccessException
	 * @return mixed
	 */
	public static function __callStatic($name, $args)
	{
		return ObjectMixin::callStatic(get_called_class(), $name, $args);
	}



	/**
	 * Adding method to class.
	 *
	 * @param $name
	 * @param null $callback
	 *
	 * @throws \Nette\MemberAccessException
	 * @return callable|null
	 */
	public static function extensionMethod($name, $callback = NULL)
	{
		if (strpos($name, '::') === FALSE) {
			$class = get_called_class();
		} else {
			list($class, $name) = explode('::', $name);
		}
		if ($callback === NULL) {
			return ObjectMixin::getExtensionMethod($class, $name);
		} else {
			ObjectMixin::setExtensionMethod($class, $name, $callback);
		}
	}



	/**
	 * Returns property value. Do not call directly.
	 *
	 * @param string $name
	 *
	 * @throws \Nette\MemberAccessException
	 * @return mixed
	 */
	public function &__get($name)
	{
		return ObjectMixin::get($this, $name);
	}



	/**
	 * Sets value of a property. Do not call directly.
	 *
	 * @param string $name
	 * @param mixed $value
	 *
	 * @throws \Nette\MemberAccessException
	 * @return void
	 */
	public function __set($name, $value)
	{
		ObjectMixin::set($this, $name, $value);
	}



	/**
	 * Is property defined?
	 *
	 * @param string $name
	 *
	 * @return bool
	 */
	public function __isset($name)
	{
		return ObjectMixin::has($this, $name);
	}



	/**
	 * Access to undeclared property.
	 *
	 * @param string $name
	 *
	 * @throws \Nette\MemberAccessException
	 * @return void
	 */
	public function __unset($name)
	{
		ObjectMixin::remove($this, $name);
	}

}


Push — master ( d88939...76eafd )

EntityManager::extensionMethod() A

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

1			<?php
2
3			/**
4			* This file is part of the Kdyby (http://www.kdyby.org)
5			*
6			* Copyright (c) 2008 Filip Procházka ([email protected])
7			*
8			* For the full copyright and license information, please view the file license.txt that was distributed with this source code.
9			*/
10
11			namespace Kdyby\Doctrine;
12
13			use Doctrine;
14			use Doctrine\DBAL\DriverManager;
15			use Doctrine\ORM\AbstractQuery;
16			use Doctrine\ORM\ORMException;
17			use Doctrine\ORM\Query;
18			use Kdyby;
19			use Kdyby\Doctrine\QueryObject;
20			use Kdyby\Doctrine\Tools\NonLockingUniqueInserter;
21			use Kdyby\Persistence;
22			use Nette;
23			use Nette\Utils\ObjectMixin;
24
25
26
27			/**
28			* @author Filip Procházka <[email protected]>
29			*
30			* @method \Kdyby\Doctrine\Connection getConnection()
31			* @method \Kdyby\Doctrine\Configuration getConfiguration()
32			* @method \Kdyby\Doctrine\EntityRepository getRepository($entityName)
33			*/
34			class EntityManager extends Doctrine\ORM\EntityManager implements Persistence\QueryExecutor, Persistence\Queryable
			0 ignored issues – show Bug introduced 2017-03-08 16:40 UTC by Report Bug Copy Issue Report There is at least one abstract method in this class. Maybe declare it as abstract, or implement the remaining methods: createNativeQuery, createQuery Loading history...
35			{
36
37			/**
38			* @var NonLockingUniqueInserter
39			*/
40			private $nonLockingUniqueInserter;
41
42			/**
43			* @var Diagnostics\Panel
44			*/
45			private $panel;
46
47
48
49			protected function __construct(Doctrine\DBAL\Connection $conn, Doctrine\ORM\Configuration $config, Doctrine\Common\EventManager $eventManager)
50			{
51			parent::__construct($conn, $config, $eventManager);
52
53			if ($conn instanceof Kdyby\Doctrine\Connection) {
54			$conn->bindEntityManager($this);
55			}
56			}
57
58
59
60			/**
61			* @internal
62			* @param Diagnostics\Panel $panel
63			*/
64			public function bindTracyPanel(Diagnostics\Panel $panel)
65			{
66			$this->panel = $panel;
67			}
68
69
70
71			/**
72			* @throws NotSupportedException
73			* @return \Kdyby\Doctrine\QueryBuilder
74			*/
75			public function createQueryBuilder($alias = NULL, $indexBy = NULL)
76			{
77			if ($alias !== NULL \|\| $indexBy !== NULL) {
78			throw new NotSupportedException('Use EntityRepository for $alias and $indexBy arguments to work.');
79			}
80
81			if (($config = $this->getConfiguration()) instanceof Configuration) {
82			$class = $config->getQueryBuilderClassName();
83			return new $class($this);
84			}
85
86			return new QueryBuilder($this);
87			}
88
89
90
91			/**
92			* {@inheritdoc}
93			* @param string\|array $entity
			0 ignored issues – show Documentation introduced 2015-11-23 18:47 UTC by Report Bug Copy Issue Report There is no parameter named `$entity`. Did you maybe mean `$entityName`? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. It has, however, found a similar but not annotated parameter which might be a good fit. Consider the following example. The parameter `$ireland` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $ireland */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was changed, but the annotation was not. Loading history...
94			* @return EntityManager
95			*/
96			public function clear($entityName = null)
97			{
98			foreach (is_array($entityName) ? $entityName : (func_get_args() + [0 => NULL]) as $item) {
99			parent::clear($item);
100			}
101
102			return $this;
103			}
104
105
106
107			/**
108			* {@inheritdoc}
109			* @param object\|array $entity
110			* @return EntityManager
111			*/
112			public function remove($entity)
113			{
114			foreach (is_array($entity) ? $entity : func_get_args() as $item) {
115			parent::remove($item);
116			}
117
118			return $this;
119			}
120
121
122
123			/**
124			* {@inheritdoc}
125			* @param object\|array $entity
126			* @return EntityManager
127			*/
128			public function persist($entity)
129			{
130			foreach (is_array($entity) ? $entity : func_get_args() as $item) {
131			parent::persist($item);
132			}
133
134			return $this;
135			}
136
137
138
139			/**
140			* {@inheritdoc}
141			* @param object\|array $entity
142			* @return EntityManager
143			*/
144			public function flush($entity = null)
145			{
146			try {
147			parent::flush($entity);
148
149			} catch (\Exception $e) {
150			if ($this->panel) {
151			$this->panel->markExceptionOwner($this, $e);
152			}
153
154			throw $e;
155			}
156
157			return $this;
158			}
159
160
161
162			public function close()
163			{
164			if ($this->panel) {
165			$this->panel->snapshotUnitOfWork($this);
166			}
167
168			parent::close();
169			}
170
171
172
173			/**
174			* Tries to persist the given entity and returns FALSE if an unique
175			* constaint was violated.
176			*
177			* Warning: On success you must NOT use the passed entity further
178			* in your application. Use the returned one instead!
179			*
180			* @param $entity
181			* @throws \Doctrine\DBAL\DBALException
182			* @throws \Exception
183			* @return bool\|object
184			*/
185			public function safePersist($entity)
186			{
187			if ($this->nonLockingUniqueInserter === NULL) {
188			$this->nonLockingUniqueInserter = new NonLockingUniqueInserter($this);
189			}
190
191			return $this->nonLockingUniqueInserter->persist($entity);
192			}
193
194
195
196			/**
197			* @param int $hydrationMode
198			* @return Doctrine\ORM\Internal\Hydration\AbstractHydrator
199			* @throws \Doctrine\ORM\ORMException
200			*/
201			public function newHydrator($hydrationMode)
202			{
203			switch ($hydrationMode) {
204			case Hydration\HashHydrator::NAME:
205			return new Hydration\HashHydrator($this);
206
207			default:
208			return parent::newHydrator($hydrationMode);
209			}
210			}
211
212
213
214			/**
215			* Factory method to create EntityManager instances.
216			*
217			* @param \Doctrine\DBAL\Connection\|array $conn
218			* @param \Doctrine\ORM\Configuration $config
219			* @param \Doctrine\Common\EventManager $eventManager
220			* @throws \Doctrine\ORM\ORMException
221			* @throws \InvalidArgumentException
222			* @throws \Doctrine\ORM\ORMException
223			* @return EntityManager
224			*/
225			public static function create($conn, Doctrine\ORM\Configuration $config, Doctrine\Common\EventManager $eventManager = NULL)
226			{
227			if (!$config->getMetadataDriverImpl()) {
228			throw ORMException::missingMappingDriverImpl();
229			}
230
231			switch (TRUE) {
232			case (is_array($conn)):
233			$conn = DriverManager::getConnection(
234			$conn, $config, ($eventManager ? : new Doctrine\Common\EventManager())
235			);
236			break;
237
238			case ($conn instanceof Doctrine\DBAL\Connection):
			0 ignored issues – show Bug introduced 2017-03-08 16:40 UTC by Report Bug Copy Issue Report The class `Doctrine\DBAL\Connection` does not exist. Did you forget a USE statement, or did you not list all dependencies? This error could be the result of: 1. Missing dependencies PHP Analyzer uses your `composer.json` file (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects the `composer.json` to be in the root folder of your repository. Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the `require` or `require-dev` section? 2. Missing use statement PHP does not complain about undefined classes in `ìnstanceof` checks. For example, the following PHP code will work perfectly fine: if ($x instanceof DoesNotExist) { // Do something. } If you have not tested against this specific condition, such errors might go unnoticed. Loading history...
239			if ($eventManager !== NULL && $conn->getEventManager() !== $eventManager) {
240			throw ORMException::mismatchedEventManager();
241			}
242			break;
243
244			default:
245			throw new \InvalidArgumentException("Invalid connection");
246			}
247
248			return new EntityManager($conn, $config, $conn->getEventManager());
249			}
250
251
252
253			/**************** Kdyby\Persistence\QueryExecutor ***************/
254
255
256
257			/**
258			* @param \Kdyby\Persistence\Query\|\Kdyby\Doctrine\QueryObject $queryObject
259			* @param int $hydrationMode
260			* @throws QueryException
261			* @return array\|\Kdyby\Doctrine\ResultSet
262			*/
263			public function fetch(Persistence\Query $queryObject, $hydrationMode = AbstractQuery::HYDRATE_OBJECT)
264			{
265			try {
266			return $queryObject->fetch($this, $hydrationMode);
			0 ignored issues – show Unused Code introduced 2015-11-23 18:47 UTC by Report Bug Copy Issue Report The call to `Query::fetch()` has too many arguments starting with `$hydrationMode`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
267
268			} catch (\Exception $e) {
269			throw $this->handleQueryException($e, $queryObject);
270			}
271			}
272
273
274
275			/**
276			* @param \Kdyby\Persistence\Query\|\Kdyby\Doctrine\QueryObject $queryObject
277			*
278			* @throws InvalidStateException
279			* @throws QueryException
280			* @return object\|NULL
281			*/
282			public function fetchOne(Persistence\Query $queryObject)
283			{
284			try {
285			return $queryObject->fetchOne($this);
286
287			} catch (Doctrine\ORM\NoResultException $e) {
			0 ignored issues – show Bug introduced 2017-03-08 16:40 UTC by Report Bug Copy Issue Report The class `Doctrine\ORM\NoResultException` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
288			return NULL;
289
290			} catch (Doctrine\ORM\NonUniqueResultException $e) { // this should never happen!
			0 ignored issues – show Bug introduced 2017-03-08 16:40 UTC by Report Bug Copy Issue Report The class `Doctrine\ORM\NonUniqueResultException` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
291			throw new InvalidStateException("You have to setup your query calling ->setMaxResult(1).", 0, $e);
292
293			} catch (\Exception $e) {
294			throw $this->handleQueryException($e, $queryObject);
295			}
296			}
297
298
299
300			/**
301			* @param \Exception $e
302			* @param \Kdyby\Persistence\Query $queryObject
303			*
304			* @throws \Exception
305			*/
306			private function handleQueryException(\Exception $e, Persistence\Query $queryObject)
307			{
308			$lastQuery = $queryObject instanceof QueryObject ? $queryObject->getLastQuery() : NULL;
309
310			return new QueryException($e, $lastQuery, '['.get_class($queryObject).'] '.$e->getMessage());
311			}
312
313
314
315			/************************* Nette\Object *************************/
316
317
318
319			/**
320			* Access to reflection.
321			*
322			* @return \Nette\Reflection\ClassType
323			*/
324			public static function getReflection()
325			{
326			return new Nette\Reflection\ClassType(get_called_class());
327			}
328
329
330
331			/**
332			* Call to undefined method.
333			*
334			* @param string $name
335			* @param array $args
336			*
337			* @throws \Nette\MemberAccessException
338			* @return mixed
339			*/
340			public function __call($name, $args)
341			{
342			return ObjectMixin::call($this, $name, $args);
343			}
344
345
346
347			/**
348			* Call to undefined static method.
349			*
350			* @param string $name
351			* @param array $args
352			*
353			* @throws \Nette\MemberAccessException
354			* @return mixed
355			*/
356			public static function __callStatic($name, $args)
357			{
358			return ObjectMixin::callStatic(get_called_class(), $name, $args);
359			}
360
361
362
363			/**
364			* Adding method to class.
365			*
366			* @param $name
367			* @param null $callback
368			*
369			* @throws \Nette\MemberAccessException
370			* @return callable\|null
371			*/
372			public static function extensionMethod($name, $callback = NULL)
373			{
374			if (strpos($name, '::') === FALSE) {
375			$class = get_called_class();
376			} else {
377			list($class, $name) = explode('::', $name);
378			}
379			if ($callback === NULL) {
380			return ObjectMixin::getExtensionMethod($class, $name);
381			} else {
382			ObjectMixin::setExtensionMethod($class, $name, $callback);
383			}
384			}
385
386
387
388			/**
389			* Returns property value. Do not call directly.
390			*
391			* @param string $name
392			*
393			* @throws \Nette\MemberAccessException
394			* @return mixed
395			*/
396			public function &__get($name)
397			{
398			return ObjectMixin::get($this, $name);
399			}
400
401
402
403			/**
404			* Sets value of a property. Do not call directly.
405			*
406			* @param string $name
407			* @param mixed $value
408			*
409			* @throws \Nette\MemberAccessException
410			* @return void
411			*/
412			public function __set($name, $value)
413			{
414			ObjectMixin::set($this, $name, $value);
415			}
416
417
418
419			/**
420			* Is property defined?
421			*
422			* @param string $name
423			*
424			* @return bool
425			*/
426			public function __isset($name)
427			{
428			return ObjectMixin::has($this, $name);
429			}
430
431
432
433			/**
434			* Access to undeclared property.
435			*
436			* @param string $name
437			*
438			* @throws \Nette\MemberAccessException
439			* @return void
440			*/
441			public function __unset($name)
442			{
443			ObjectMixin::remove($this, $name);
444			}
445
446			}
447

Kdyby / Doctrine

Push — master ( d88939...76eafd )

EntityManager::extensionMethod() A

Complexity

Size

Duplication

Importance

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like