RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2025-03-06 21:06:16 +03:00
Code Issues Projects Releases Wiki Activity

Use "::class" syntax on "lib" directory

Browse Source
This commit is contained in:
Luís Cobucci 2016-12-08 17:09:35 +01:00
parent 234989d069
commit 512aa8a3c7
No known key found for this signature in database
GPG Key ID: 8042585A7DBC92E1
12 changed files with 126 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/Doctrine/ORM/Configuration.php
View File

@ -25,9 +25,11 @@ use Doctrine\Common\Annotations\CachedReader;
use Doctrine\Common\Annotations\SimpleAnnotationReader; use Doctrine\Common\Annotations\SimpleAnnotationReader;
use Doctrine\Common\Cache\ArrayCache; use Doctrine\Common\Cache\ArrayCache;
use Doctrine\Common\Cache\Cache as CacheDriver; use Doctrine\Common\Cache\Cache as CacheDriver;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver;
use Doctrine\Common\Persistence\ObjectRepository;
use Doctrine\Common\Proxy\AbstractProxyFactory; use Doctrine\Common\Proxy\AbstractProxyFactory;
use Doctrine\ORM\Cache\CacheConfiguration; use Doctrine\ORM\Cache\CacheConfiguration;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver; use Doctrine\ORM\Mapping\ClassMetadataFactory;
use Doctrine\ORM\Mapping\DefaultEntityListenerResolver; use Doctrine\ORM\Mapping\DefaultEntityListenerResolver;
use Doctrine\ORM\Mapping\DefaultNamingStrategy; use Doctrine\ORM\Mapping\DefaultNamingStrategy;
use Doctrine\ORM\Mapping\DefaultQuoteStrategy; use Doctrine\ORM\Mapping\DefaultQuoteStrategy;
@ -642,7 +644,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
public function getClassMetadataFactoryName() public function getClassMetadataFactoryName()
{ {
if ( ! isset($this->_attributes['classMetadataFactoryName'])) { if ( ! isset($this->_attributes['classMetadataFactoryName'])) {
$this->_attributes['classMetadataFactoryName'] = 'Doctrine\ORM\Mapping\ClassMetadataFactory'; $this->_attributes['classMetadataFactoryName'] = ClassMetadataFactory::class;
} }
return $this->_attributes['classMetadataFactoryName']; return $this->_attributes['classMetadataFactoryName'];
@ -689,7 +691,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
{ {
$reflectionClass = new \ReflectionClass($className); $reflectionClass = new \ReflectionClass($className);
if ( ! $reflectionClass->implementsInterface('Doctrine\Common\Persistence\ObjectRepository')) { if ( ! $reflectionClass->implementsInterface(ObjectRepository::class)) {
throw ORMException::invalidEntityRepository($className); throw ORMException::invalidEntityRepository($className);
} }
@ -707,7 +709,7 @@ class Configuration extends \Doctrine\DBAL\Configuration
{ {
return isset($this->_attributes['defaultRepositoryClassName']) return isset($this->_attributes['defaultRepositoryClassName'])
? $this->_attributes['defaultRepositoryClassName'] ? $this->_attributes['defaultRepositoryClassName']
: 'Doctrine\ORM\EntityRepository'; : EntityRepository::class;
} }
/** /**

137
lib/Doctrine/ORM/Mapping/Driver/AnnotationDriver.php
View File

@ -20,13 +20,12 @@
namespace Doctrine\ORM\Mapping\Driver; namespace Doctrine\ORM\Mapping\Driver;
use Doctrine\Common\Annotations\AnnotationReader; use Doctrine\Common\Annotations\AnnotationReader;
use Doctrine\ORM\Mapping\MappingException;
use Doctrine\ORM\Mapping\JoinColumn;
use Doctrine\ORM\Mapping\Column;
use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
use Doctrine\Common\Persistence\Mapping\ClassMetadata; use Doctrine\Common\Persistence\Mapping\ClassMetadata;
use Doctrine\Common\Persistence\Mapping\Driver\AnnotationDriver as AbstractAnnotationDriver; use Doctrine\Common\Persistence\Mapping\Driver\AnnotationDriver as AbstractAnnotationDriver;
use Doctrine\ORM\Events; use Doctrine\ORM\Events;
use Doctrine\ORM\Mapping;
use Doctrine\ORM\Mapping\Builder\EntityListenerBuilder;
use Doctrine\ORM\Mapping\MappingException;
/** /**
* The AnnotationDriver reads the mapping metadata from docblock annotations. * The AnnotationDriver reads the mapping metadata from docblock annotations.
@ -43,8 +42,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
* {@inheritDoc} * {@inheritDoc}
*/ */
protected $entityAnnotationClasses = [ protected $entityAnnotationClasses = [
'Doctrine\ORM\Mapping\Entity' => 1, Mapping\Entity::class => 1,
'Doctrine\ORM\Mapping\MappedSuperclass' => 2, Mapping\MappedSuperclass::class => 2,
]; ];
/** /**
@ -74,8 +73,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate Entity annotation // Evaluate Entity annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\Entity'])) { if (isset($classAnnotations[Mapping\Entity::class])) {
$entityAnnot = $classAnnotations['Doctrine\ORM\Mapping\Entity']; $entityAnnot = $classAnnotations[Mapping\Entity::class];
if ($entityAnnot->repositoryClass !== null) { if ($entityAnnot->repositoryClass !== null) {
$metadata->setCustomRepositoryClass($entityAnnot->repositoryClass); $metadata->setCustomRepositoryClass($entityAnnot->repositoryClass);
} }
@ -83,20 +82,20 @@ class AnnotationDriver extends AbstractAnnotationDriver
if ($entityAnnot->readOnly) { if ($entityAnnot->readOnly) {
$metadata->markReadOnly(); $metadata->markReadOnly();
} }
} else if (isset($classAnnotations['Doctrine\ORM\Mapping\MappedSuperclass'])) { } else if (isset($classAnnotations[Mapping\MappedSuperclass::class])) {
$mappedSuperclassAnnot = $classAnnotations['Doctrine\ORM\Mapping\MappedSuperclass']; $mappedSuperclassAnnot = $classAnnotations[Mapping\MappedSuperclass::class];
$metadata->setCustomRepositoryClass($mappedSuperclassAnnot->repositoryClass); $metadata->setCustomRepositoryClass($mappedSuperclassAnnot->repositoryClass);
$metadata->isMappedSuperclass = true; $metadata->isMappedSuperclass = true;
} else if (isset($classAnnotations['Doctrine\ORM\Mapping\Embeddable'])) { } else if (isset($classAnnotations[Mapping\Embeddable::class])) {
$metadata->isEmbeddedClass = true; $metadata->isEmbeddedClass = true;
} else { } else {
throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className); throw MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
} }
// Evaluate Table annotation // Evaluate Table annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\Table'])) { if (isset($classAnnotations[Mapping\Table::class])) {
$tableAnnot = $classAnnotations['Doctrine\ORM\Mapping\Table']; $tableAnnot = $classAnnotations[Mapping\Table::class];
$primaryTable = [ $primaryTable = [
'name' => $tableAnnot->name, 'name' => $tableAnnot->name,
'schema' => $tableAnnot->schema 'schema' => $tableAnnot->schema
@ -146,8 +145,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate @Cache annotation // Evaluate @Cache annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\Cache'])) { if (isset($classAnnotations[Mapping\Cache::class])) {
$cacheAnnot = $classAnnotations['Doctrine\ORM\Mapping\Cache']; $cacheAnnot = $classAnnotations[Mapping\Cache::class];
$cacheMap = [ $cacheMap = [
'region' => $cacheAnnot->region, 'region' => $cacheAnnot->region,
'usage' => constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $cacheAnnot->usage), 'usage' => constant('Doctrine\ORM\Mapping\ClassMetadata::CACHE_USAGE_' . $cacheAnnot->usage),
@ -157,8 +156,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate NamedNativeQueries annotation // Evaluate NamedNativeQueries annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\NamedNativeQueries'])) { if (isset($classAnnotations[Mapping\NamedNativeQueries::class])) {
$namedNativeQueriesAnnot = $classAnnotations['Doctrine\ORM\Mapping\NamedNativeQueries']; $namedNativeQueriesAnnot = $classAnnotations[Mapping\NamedNativeQueries::class];
foreach ($namedNativeQueriesAnnot->value as $namedNativeQuery) { foreach ($namedNativeQueriesAnnot->value as $namedNativeQuery) {
$metadata->addNamedNativeQuery( $metadata->addNamedNativeQuery(
@ -173,8 +172,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate SqlResultSetMappings annotation // Evaluate SqlResultSetMappings annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\SqlResultSetMappings'])) { if (isset($classAnnotations[Mapping\SqlResultSetMappings::class])) {
$sqlResultSetMappingsAnnot = $classAnnotations['Doctrine\ORM\Mapping\SqlResultSetMappings']; $sqlResultSetMappingsAnnot = $classAnnotations[Mapping\SqlResultSetMappings::class];
foreach ($sqlResultSetMappingsAnnot->value as $resultSetMapping) { foreach ($sqlResultSetMappingsAnnot->value as $resultSetMapping) {
$entities = []; $entities = [];
@ -213,15 +212,15 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate NamedQueries annotation // Evaluate NamedQueries annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\NamedQueries'])) { if (isset($classAnnotations[Mapping\NamedQueries::class])) {
$namedQueriesAnnot = $classAnnotations['Doctrine\ORM\Mapping\NamedQueries']; $namedQueriesAnnot = $classAnnotations[Mapping\NamedQueries::class];
if ( ! is_array($namedQueriesAnnot->value)) { if ( ! is_array($namedQueriesAnnot->value)) {
throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations."); throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
} }
foreach ($namedQueriesAnnot->value as $namedQuery) { foreach ($namedQueriesAnnot->value as $namedQuery) {
if ( ! ($namedQuery instanceof \Doctrine\ORM\Mapping\NamedQuery)) { if ( ! ($namedQuery instanceof Mapping\NamedQuery)) {
throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations."); throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
} }
$metadata->addNamedQuery( $metadata->addNamedQuery(
@ -234,17 +233,17 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate InheritanceType annotation // Evaluate InheritanceType annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\InheritanceType'])) { if (isset($classAnnotations[Mapping\InheritanceType::class])) {
$inheritanceTypeAnnot = $classAnnotations['Doctrine\ORM\Mapping\InheritanceType']; $inheritanceTypeAnnot = $classAnnotations[Mapping\InheritanceType::class];
$metadata->setInheritanceType( $metadata->setInheritanceType(
constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . $inheritanceTypeAnnot->value) constant('Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_' . $inheritanceTypeAnnot->value)
); );
if ($metadata->inheritanceType != \Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_NONE) { if ($metadata->inheritanceType != Mapping\ClassMetadata::INHERITANCE_TYPE_NONE) {
// Evaluate DiscriminatorColumn annotation // Evaluate DiscriminatorColumn annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\DiscriminatorColumn'])) { if (isset($classAnnotations[Mapping\DiscriminatorColumn::class])) {
$discrColumnAnnot = $classAnnotations['Doctrine\ORM\Mapping\DiscriminatorColumn']; $discrColumnAnnot = $classAnnotations[Mapping\DiscriminatorColumn::class];
$metadata->setDiscriminatorColumn( $metadata->setDiscriminatorColumn(
[ [
@ -259,8 +258,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate DiscriminatorMap annotation // Evaluate DiscriminatorMap annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\DiscriminatorMap'])) { if (isset($classAnnotations[Mapping\DiscriminatorMap::class])) {
$discrMapAnnot = $classAnnotations['Doctrine\ORM\Mapping\DiscriminatorMap']; $discrMapAnnot = $classAnnotations[Mapping\DiscriminatorMap::class];
$metadata->setDiscriminatorMap($discrMapAnnot->value); $metadata->setDiscriminatorMap($discrMapAnnot->value);
} }
} }
@ -268,8 +267,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
// Evaluate DoctrineChangeTrackingPolicy annotation // Evaluate DoctrineChangeTrackingPolicy annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\ChangeTrackingPolicy'])) { if (isset($classAnnotations[Mapping\ChangeTrackingPolicy::class])) {
$changeTrackingAnnot = $classAnnotations['Doctrine\ORM\Mapping\ChangeTrackingPolicy']; $changeTrackingAnnot = $classAnnotations[Mapping\ChangeTrackingPolicy::class];
$metadata->setChangeTrackingPolicy(constant('Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_' . $changeTrackingAnnot->value)); $metadata->setChangeTrackingPolicy(constant('Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_' . $changeTrackingAnnot->value));
} }
@ -290,7 +289,7 @@ class AnnotationDriver extends AbstractAnnotationDriver
$mapping['fieldName'] = $property->getName(); $mapping['fieldName'] = $property->getName();
// Evaluate @Cache annotation // Evaluate @Cache annotation
if (($cacheAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Cache')) !== null) { if (($cacheAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Cache::class)) !== null) {
$mapping['cache'] = $metadata->getAssociationCacheDefaults( $mapping['cache'] = $metadata->getAssociationCacheDefaults(
$mapping['fieldName'], $mapping['fieldName'],
[ [
@ -302,9 +301,9 @@ class AnnotationDriver extends AbstractAnnotationDriver
// Check for JoinColumn/JoinColumns annotations // Check for JoinColumn/JoinColumns annotations
$joinColumns = []; $joinColumns = [];
if ($joinColumnAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinColumn')) { if ($joinColumnAnnot = $this->reader->getPropertyAnnotation($property, Mapping\JoinColumn::class)) {
$joinColumns[] = $this->joinColumnToArray($joinColumnAnnot); $joinColumns[] = $this->joinColumnToArray($joinColumnAnnot);
} else if ($joinColumnsAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinColumns')) { } else if ($joinColumnsAnnot = $this->reader->getPropertyAnnotation($property, Mapping\JoinColumns::class)) {
foreach ($joinColumnsAnnot->value as $joinColumn) { foreach ($joinColumnsAnnot->value as $joinColumn) {
$joinColumns[] = $this->joinColumnToArray($joinColumn); $joinColumns[] = $this->joinColumnToArray($joinColumn);
} }
@ -312,29 +311,29 @@ class AnnotationDriver extends AbstractAnnotationDriver
// Field can only be annotated with one of: // Field can only be annotated with one of:
// @Column, @OneToOne, @OneToMany, @ManyToOne, @ManyToMany // @Column, @OneToOne, @OneToMany, @ManyToOne, @ManyToMany
if ($columnAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Column')) { if ($columnAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Column::class)) {
if ($columnAnnot->type == null) { if ($columnAnnot->type == null) {
throw MappingException::propertyTypeIsRequired($className, $property->getName()); throw MappingException::propertyTypeIsRequired($className, $property->getName());
} }
$mapping = $this->columnToArray($property->getName(), $columnAnnot); $mapping = $this->columnToArray($property->getName(), $columnAnnot);
if ($idAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) { if ($idAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Id::class)) {
$mapping['id'] = true; $mapping['id'] = true;
} }
if ($generatedValueAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\GeneratedValue')) { if ($generatedValueAnnot = $this->reader->getPropertyAnnotation($property, Mapping\GeneratedValue::class)) {
$metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $generatedValueAnnot->strategy)); $metadata->setIdGeneratorType(constant('Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_' . $generatedValueAnnot->strategy));
} }
if ($this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Version')) { if ($this->reader->getPropertyAnnotation($property, Mapping\Version::class)) {
$metadata->setVersionMapping($mapping); $metadata->setVersionMapping($mapping);
} }
$metadata->mapField($mapping); $metadata->mapField($mapping);
// Check for SequenceGenerator/TableGenerator definition // Check for SequenceGenerator/TableGenerator definition
if ($seqGeneratorAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\SequenceGenerator')) { if ($seqGeneratorAnnot = $this->reader->getPropertyAnnotation($property, Mapping\SequenceGenerator::class)) {
$metadata->setSequenceGeneratorDefinition( $metadata->setSequenceGeneratorDefinition(
[ [
'sequenceName' => $seqGeneratorAnnot->sequenceName, 'sequenceName' => $seqGeneratorAnnot->sequenceName,
@ -344,15 +343,15 @@ class AnnotationDriver extends AbstractAnnotationDriver
); );
} else if ($this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\TableGenerator')) { } else if ($this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\TableGenerator')) {
throw MappingException::tableIdGeneratorNotImplemented($className); throw MappingException::tableIdGeneratorNotImplemented($className);
} else if ($customGeneratorAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\CustomIdGenerator')) { } else if ($customGeneratorAnnot = $this->reader->getPropertyAnnotation($property, Mapping\CustomIdGenerator::class)) {
$metadata->setCustomGeneratorDefinition( $metadata->setCustomGeneratorDefinition(
[ [
'class' => $customGeneratorAnnot->class 'class' => $customGeneratorAnnot->class
] ]
); );
} }
} else if ($oneToOneAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OneToOne')) { } else if ($oneToOneAnnot = $this->reader->getPropertyAnnotation($property, Mapping\OneToOne::class)) {
if ($idAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) { if ($idAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Id::class)) {
$mapping['id'] = true; $mapping['id'] = true;
} }
@ -364,7 +363,7 @@ class AnnotationDriver extends AbstractAnnotationDriver
$mapping['orphanRemoval'] = $oneToOneAnnot->orphanRemoval; $mapping['orphanRemoval'] = $oneToOneAnnot->orphanRemoval;
$mapping['fetch'] = $this->getFetchMode($className, $oneToOneAnnot->fetch); $mapping['fetch'] = $this->getFetchMode($className, $oneToOneAnnot->fetch);
$metadata->mapOneToOne($mapping); $metadata->mapOneToOne($mapping);
} else if ($oneToManyAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OneToMany')) { } else if ($oneToManyAnnot = $this->reader->getPropertyAnnotation($property, Mapping\OneToMany::class)) {
$mapping['mappedBy'] = $oneToManyAnnot->mappedBy; $mapping['mappedBy'] = $oneToManyAnnot->mappedBy;
$mapping['targetEntity'] = $oneToManyAnnot->targetEntity; $mapping['targetEntity'] = $oneToManyAnnot->targetEntity;
$mapping['cascade'] = $oneToManyAnnot->cascade; $mapping['cascade'] = $oneToManyAnnot->cascade;
@ -372,13 +371,13 @@ class AnnotationDriver extends AbstractAnnotationDriver
$mapping['orphanRemoval'] = $oneToManyAnnot->orphanRemoval; $mapping['orphanRemoval'] = $oneToManyAnnot->orphanRemoval;
$mapping['fetch'] = $this->getFetchMode($className, $oneToManyAnnot->fetch); $mapping['fetch'] = $this->getFetchMode($className, $oneToManyAnnot->fetch);
if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OrderBy')) { if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, Mapping\OrderBy::class)) {
$mapping['orderBy'] = $orderByAnnot->value; $mapping['orderBy'] = $orderByAnnot->value;
} }
$metadata->mapOneToMany($mapping); $metadata->mapOneToMany($mapping);
} else if ($manyToOneAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\ManyToOne')) { } else if ($manyToOneAnnot = $this->reader->getPropertyAnnotation($property, Mapping\ManyToOne::class)) {
if ($idAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Id')) { if ($idAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Id::class)) {
$mapping['id'] = true; $mapping['id'] = true;
} }
@ -388,10 +387,10 @@ class AnnotationDriver extends AbstractAnnotationDriver
$mapping['targetEntity'] = $manyToOneAnnot->targetEntity; $mapping['targetEntity'] = $manyToOneAnnot->targetEntity;
$mapping['fetch'] = $this->getFetchMode($className, $manyToOneAnnot->fetch); $mapping['fetch'] = $this->getFetchMode($className, $manyToOneAnnot->fetch);
$metadata->mapManyToOne($mapping); $metadata->mapManyToOne($mapping);
} else if ($manyToManyAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\ManyToMany')) { } else if ($manyToManyAnnot = $this->reader->getPropertyAnnotation($property, Mapping\ManyToMany::class)) {
$joinTable = []; $joinTable = [];
if ($joinTableAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\JoinTable')) { if ($joinTableAnnot = $this->reader->getPropertyAnnotation($property, Mapping\JoinTable::class)) {
$joinTable = [ $joinTable = [
'name' => $joinTableAnnot->name, 'name' => $joinTableAnnot->name,
'schema' => $joinTableAnnot->schema 'schema' => $joinTableAnnot->schema
@ -415,12 +414,12 @@ class AnnotationDriver extends AbstractAnnotationDriver
$mapping['orphanRemoval'] = $manyToManyAnnot->orphanRemoval; $mapping['orphanRemoval'] = $manyToManyAnnot->orphanRemoval;
$mapping['fetch'] = $this->getFetchMode($className, $manyToManyAnnot->fetch); $mapping['fetch'] = $this->getFetchMode($className, $manyToManyAnnot->fetch);
if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\OrderBy')) { if ($orderByAnnot = $this->reader->getPropertyAnnotation($property, Mapping\OrderBy::class)) {
$mapping['orderBy'] = $orderByAnnot->value; $mapping['orderBy'] = $orderByAnnot->value;
} }
$metadata->mapManyToMany($mapping); $metadata->mapManyToMany($mapping);
} else if ($embeddedAnnot = $this->reader->getPropertyAnnotation($property, 'Doctrine\ORM\Mapping\Embedded')) { } else if ($embeddedAnnot = $this->reader->getPropertyAnnotation($property, Mapping\Embedded::class)) {
$mapping['class'] = $embeddedAnnot->class; $mapping['class'] = $embeddedAnnot->class;
$mapping['columnPrefix'] = $embeddedAnnot->columnPrefix; $mapping['columnPrefix'] = $embeddedAnnot->columnPrefix;
@ -429,8 +428,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate AssociationOverrides annotation // Evaluate AssociationOverrides annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\AssociationOverrides'])) { if (isset($classAnnotations[Mapping\AssociationOverrides::class])) {
$associationOverridesAnnot = $classAnnotations['Doctrine\ORM\Mapping\AssociationOverrides']; $associationOverridesAnnot = $classAnnotations[Mapping\AssociationOverrides::class];
foreach ($associationOverridesAnnot->value as $associationOverride) { foreach ($associationOverridesAnnot->value as $associationOverride) {
$override = []; $override = [];
@ -476,8 +475,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate AttributeOverrides annotation // Evaluate AttributeOverrides annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\AttributeOverrides'])) { if (isset($classAnnotations[Mapping\AttributeOverrides::class])) {
$attributeOverridesAnnot = $classAnnotations['Doctrine\ORM\Mapping\AttributeOverrides']; $attributeOverridesAnnot = $classAnnotations[Mapping\AttributeOverrides::class];
foreach ($attributeOverridesAnnot->value as $attributeOverrideAnnot) { foreach ($attributeOverridesAnnot->value as $attributeOverrideAnnot) {
$attributeOverride = $this->columnToArray($attributeOverrideAnnot->name, $attributeOverrideAnnot->column); $attributeOverride = $this->columnToArray($attributeOverrideAnnot->name, $attributeOverrideAnnot->column);
@ -487,8 +486,8 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate EntityListeners annotation // Evaluate EntityListeners annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\EntityListeners'])) { if (isset($classAnnotations[Mapping\EntityListeners::class])) {
$entityListenersAnnot = $classAnnotations['Doctrine\ORM\Mapping\EntityListeners']; $entityListenersAnnot = $classAnnotations[Mapping\EntityListeners::class];
foreach ($entityListenersAnnot->value as $item) { foreach ($entityListenersAnnot->value as $item) {
$listenerClassName = $metadata->fullyQualifiedClassName($item); $listenerClassName = $metadata->fullyQualifiedClassName($item);
@ -519,7 +518,7 @@ class AnnotationDriver extends AbstractAnnotationDriver
} }
// Evaluate @HasLifecycleCallbacks annotation // Evaluate @HasLifecycleCallbacks annotation
if (isset($classAnnotations['Doctrine\ORM\Mapping\HasLifecycleCallbacks'])) { if (isset($classAnnotations[Mapping\HasLifecycleCallbacks::class])) {
/* @var $method \ReflectionMethod */ /* @var $method \ReflectionMethod */
foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) { foreach ($class->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
foreach ($this->getMethodCallbacks($method) as $value) { foreach ($this->getMethodCallbacks($method) as $value) {
@ -561,35 +560,35 @@ class AnnotationDriver extends AbstractAnnotationDriver
$annotations = $this->reader->getMethodAnnotations($method); $annotations = $this->reader->getMethodAnnotations($method);
foreach ($annotations as $annot) { foreach ($annotations as $annot) {
if ($annot instanceof \Doctrine\ORM\Mapping\PrePersist) { if ($annot instanceof Mapping\PrePersist) {
$callbacks[] = [$method->name, Events::prePersist]; $callbacks[] = [$method->name, Events::prePersist];
} }
if ($annot instanceof \Doctrine\ORM\Mapping\PostPersist) { if ($annot instanceof Mapping\PostPersist) {
$callbacks[] = [$method->name, Events::postPersist]; $callbacks[] = [$method->name, Events::postPersist];
} }
if ($annot instanceof \Doctrine\ORM\Mapping\PreUpdate) { if ($annot instanceof Mapping\PreUpdate) {
$callbacks[] = [$method->name, Events::preUpdate]; $callbacks[] = [$method->name, Events::preUpdate];
} }
if ($annot instanceof \Doctrine\ORM\Mapping\PostUpdate) { if ($annot instanceof Mapping\PostUpdate) {
$callbacks[] = [$method->name, Events::postUpdate]; $callbacks[] = [$method->name, Events::postUpdate];
} }
if ($annot instanceof \Doctrine\ORM\Mapping\PreRemove) { if ($annot instanceof Mapping\PreRemove) {
$callbacks[] = [$method->name, Events::preRemove]; $callbacks[] = [$method->name, Events::preRemove];
} }
if ($annot instanceof \Doctrine\ORM\Mapping\PostRemove) { if ($annot instanceof Mapping\PostRemove) {
$callbacks[] = [$method->name, Events::postRemove]; $callbacks[] = [$method->name, Events::postRemove];
} }
if ($annot instanceof \Doctrine\ORM\Mapping\PostLoad) { if ($annot instanceof Mapping\PostLoad) {
$callbacks[] = [$method->name, Events::postLoad]; $callbacks[] = [$method->name, Events::postLoad];
} }
if ($annot instanceof \Doctrine\ORM\Mapping\PreFlush) { if ($annot instanceof Mapping\PreFlush) {
$callbacks[] = [$method->name, Events::preFlush]; $callbacks[] = [$method->name, Events::preFlush];
} }
} }
@ -600,10 +599,10 @@ class AnnotationDriver extends AbstractAnnotationDriver
/** /**
* Parse the given JoinColumn as array * Parse the given JoinColumn as array
* *
* @param JoinColumn $joinColumn * @param Mapping\JoinColumn $joinColumn
* @return array * @return array
*/ */
private function joinColumnToArray(JoinColumn $joinColumn) private function joinColumnToArray(Mapping\JoinColumn $joinColumn)
{ {
return [ return [
'name' => $joinColumn->name, 'name' => $joinColumn->name,
@ -619,11 +618,11 @@ class AnnotationDriver extends AbstractAnnotationDriver
* Parse the given Column as array * Parse the given Column as array
* *
* @param string $fieldName * @param string $fieldName
* @param Column $column * @param Mapping\Column $column
* *
* @return array * @return array
*/ */
private function columnToArray($fieldName, Column $column) private function columnToArray($fieldName, Mapping\Column $column)
{ {
$mapping = [ $mapping = [
'fieldName' => $fieldName, 'fieldName' => $fieldName,

2
lib/Doctrine/ORM/Mapping/Driver/DatabaseDriver.php
View File

@ -496,7 +496,7 @@ class DatabaseDriver implements MappingDriver
} }
/** /**
* Retreive schema table definition primary keys. * Retrieve schema table definition primary keys.
* *
* @param \Doctrine\DBAL\Schema\Table $table * @param \Doctrine\DBAL\Schema\Table $table
* *

2
lib/Doctrine/ORM/Proxy/ProxyFactory.php
View File

@ -76,7 +76,7 @@ class ProxyFactory extends AbstractProxyFactory
{ {
$proxyGenerator = new ProxyGenerator($proxyDir, $proxyNs); $proxyGenerator = new ProxyGenerator($proxyDir, $proxyNs);
$proxyGenerator->setPlaceholder('baseProxyInterface', 'Doctrine\ORM\Proxy\Proxy'); $proxyGenerator->setPlaceholder('baseProxyInterface', Proxy::class);
parent::__construct($proxyGenerator, $em->getMetadataFactory(), $autoGenerate); parent::__construct($proxyGenerator, $em->getMetadataFactory(), $autoGenerate);
$this->em = $em; $this->em = $em;

8
lib/Doctrine/ORM/Query/Expr/Andx.php
View File

@ -39,10 +39,10 @@ class Andx extends Composite
* @var array * @var array
*/ */
protected $allowedClasses = [ protected $allowedClasses = [
'Doctrine\ORM\Query\Expr\Comparison', Comparison::class,
'Doctrine\ORM\Query\Expr\Func', Func::class,
'Doctrine\ORM\Query\Expr\Orx', Orx::class,
'Doctrine\ORM\Query\Expr\Andx', Andx::class,
]; ];
/** /**

8
lib/Doctrine/ORM/Query/Expr/Orx.php
View File

@ -39,10 +39,10 @@ class Orx extends Composite
* @var array * @var array
*/ */
protected $allowedClasses = [ protected $allowedClasses = [
'Doctrine\ORM\Query\Expr\Comparison', Comparison::class,
'Doctrine\ORM\Query\Expr\Func', Func::class,
'Doctrine\ORM\Query\Expr\Andx', Andx::class,
'Doctrine\ORM\Query\Expr\Orx', Orx::class,
]; ];
/** /**

2
lib/Doctrine/ORM/Query/Expr/Select.php
View File

@ -43,7 +43,7 @@ class Select extends Base
/** /**
* @var array * @var array
*/ */
protected $allowedClasses = ['Doctrine\ORM\Query\Expr\Func']; protected $allowedClasses = [Func::class];
/** /**
* @return array * @return array

45
lib/Doctrine/ORM/Query/Parser.php
View File

@ -19,8 +19,9 @@
namespace Doctrine\ORM\Query; namespace Doctrine\ORM\Query;
use Doctrine\ORM\Query;
use Doctrine\ORM\Mapping\ClassMetadata; use Doctrine\ORM\Mapping\ClassMetadata;
use Doctrine\ORM\Query;
use Doctrine\ORM\Query\AST\Functions;
/** /**
* An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language. * An LL(*) recursive-descent parser for the context-free grammar of the Doctrine Query Language.
@ -41,12 +42,12 @@ class Parser
* @var array * @var array
*/ */
private static $_STRING_FUNCTIONS = [ private static $_STRING_FUNCTIONS = [
'concat' => 'Doctrine\ORM\Query\AST\Functions\ConcatFunction', 'concat' => Functions\ConcatFunction::class,
'substring' => 'Doctrine\ORM\Query\AST\Functions\SubstringFunction', 'substring' => Functions\SubstringFunction::class,
'trim' => 'Doctrine\ORM\Query\AST\Functions\TrimFunction', 'trim' => Functions\TrimFunction::class,
'lower' => 'Doctrine\ORM\Query\AST\Functions\LowerFunction', 'lower' => Functions\LowerFunction::class,
'upper' => 'Doctrine\ORM\Query\AST\Functions\UpperFunction', 'upper' => Functions\UpperFunction::class,
'identity' => 'Doctrine\ORM\Query\AST\Functions\IdentityFunction', 'identity' => Functions\IdentityFunction::class,
]; ];
/** /**
@ -55,15 +56,15 @@ class Parser
* @var array * @var array
*/ */
private static $_NUMERIC_FUNCTIONS = [ private static $_NUMERIC_FUNCTIONS = [
'length' => 'Doctrine\ORM\Query\AST\Functions\LengthFunction', 'length' => Functions\LengthFunction::class,
'locate' => 'Doctrine\ORM\Query\AST\Functions\LocateFunction', 'locate' => Functions\LocateFunction::class,
'abs' => 'Doctrine\ORM\Query\AST\Functions\AbsFunction', 'abs' => Functions\AbsFunction::class,
'sqrt' => 'Doctrine\ORM\Query\AST\Functions\SqrtFunction', 'sqrt' => Functions\SqrtFunction::class,
'mod' => 'Doctrine\ORM\Query\AST\Functions\ModFunction', 'mod' => Functions\ModFunction::class,
'size' => 'Doctrine\ORM\Query\AST\Functions\SizeFunction', 'size' => Functions\SizeFunction::class,
'date_diff' => 'Doctrine\ORM\Query\AST\Functions\DateDiffFunction', 'date_diff' => Functions\DateDiffFunction::class,
'bit_and' => 'Doctrine\ORM\Query\AST\Functions\BitAndFunction', 'bit_and' => Functions\BitAndFunction::class,
'bit_or' => 'Doctrine\ORM\Query\AST\Functions\BitOrFunction', 'bit_or' => Functions\BitOrFunction::class,
]; ];
/** /**
@ -72,11 +73,11 @@ class Parser
* @var array * @var array
*/ */
private static $_DATETIME_FUNCTIONS = [ private static $_DATETIME_FUNCTIONS = [
'current_date' => 'Doctrine\ORM\Query\AST\Functions\CurrentDateFunction', 'current_date' => Functions\CurrentDateFunction::class,
'current_time' => 'Doctrine\ORM\Query\AST\Functions\CurrentTimeFunction', 'current_time' => Functions\CurrentTimeFunction::class,
'current_timestamp' => 'Doctrine\ORM\Query\AST\Functions\CurrentTimestampFunction', 'current_timestamp' => Functions\CurrentTimestampFunction::class,
'date_add' => 'Doctrine\ORM\Query\AST\Functions\DateAddFunction', 'date_add' => Functions\DateAddFunction::class,
'date_sub' => 'Doctrine\ORM\Query\AST\Functions\DateSubFunction', 'date_sub' => Functions\DateSubFunction::class,
]; ];
/* /*
@ -396,7 +397,7 @@ class Parser
$this->queryComponents = $treeWalkerChain->getQueryComponents(); $this->queryComponents = $treeWalkerChain->getQueryComponents();
} }
$outputWalkerClass = $this->customOutputWalker ?: __NAMESPACE__ . '\SqlWalker'; $outputWalkerClass = $this->customOutputWalker ?: SqlWalker::class;
$outputWalker = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents); $outputWalker = new $outputWalkerClass($this->query, $this->parserResult, $this->queryComponents);
// Assign an SQL executor to the parser result // Assign an SQL executor to the parser result

5
lib/Doctrine/ORM/Tools/EntityGenerator.php
View File

@ -19,9 +19,10 @@
namespace Doctrine\ORM\Tools; namespace Doctrine\ORM\Tools;
use Doctrine\ORM\Mapping\ClassMetadataInfo; use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Util\Inflector; use Doctrine\Common\Util\Inflector;
use Doctrine\DBAL\Types\Type; use Doctrine\DBAL\Types\Type;
use Doctrine\ORM\Mapping\ClassMetadataInfo;
/** /**
* Generic class used to generate PHP5 entity classes from ClassMetadataInfo instances. * Generic class used to generate PHP5 entity classes from ClassMetadataInfo instances.
@ -1216,7 +1217,7 @@ public function __construct(<params>)
if ($code = $this->generateEntityStubMethod($metadata, 'remove', $associationMapping['fieldName'], $associationMapping['targetEntity'])) { if ($code = $this->generateEntityStubMethod($metadata, 'remove', $associationMapping['fieldName'], $associationMapping['targetEntity'])) {
$methods[] = $code; $methods[] = $code;
} }
if ($code = $this->generateEntityStubMethod($metadata, 'get', $associationMapping['fieldName'], 'Doctrine\Common\Collections\Collection')) { if ($code = $this->generateEntityStubMethod($metadata, 'get', $associationMapping['fieldName'], Collection::class)) {
$methods[] = $code; $methods[] = $code;
} }
} }

4
lib/Doctrine/ORM/Tools/EntityRepositoryGenerator.php
View File

@ -19,6 +19,8 @@
namespace Doctrine\ORM\Tools; namespace Doctrine\ORM\Tools;
use Doctrine\ORM\EntityRepository;
/** /**
* Class to generate entity repository classes * Class to generate entity repository classes
* *
@ -123,7 +125,7 @@ class <className> extends <repositoryName>
{ {
$namespace = $this->getClassNamespace($fullClassName); $namespace = $this->getClassNamespace($fullClassName);
$repositoryName = $this->repositoryName ?: 'Doctrine\ORM\EntityRepository'; $repositoryName = $this->repositoryName ?: EntityRepository::class;
if ($namespace && $repositoryName[0] !== '\\') { if ($namespace && $repositoryName[0] !== '\\') {
$repositoryName = '\\' . $repositoryName; $repositoryName = '\\' . $repositoryName;

10
lib/Doctrine/ORM/Tools/Export/ClassMetadataExporter.php
View File

@ -33,11 +33,11 @@ class ClassMetadataExporter
* @var array * @var array
*/ */
private static $_exporterDrivers = [ private static $_exporterDrivers = [
'xml' => 'Doctrine\ORM\Tools\Export\Driver\XmlExporter', 'xml' => Driver\XmlExporter::class,
'yaml' => 'Doctrine\ORM\Tools\Export\Driver\YamlExporter', 'yaml' => Driver\YamlExporter::class,
'yml' => 'Doctrine\ORM\Tools\Export\Driver\YamlExporter', 'yml' => Driver\YamlExporter::class,
'php' => 'Doctrine\ORM\Tools\Export\Driver\PhpExporter', 'php' => Driver\PhpExporter::class,
'annotation' => 'Doctrine\ORM\Tools\Export\Driver\AnnotationExporter' 'annotation' => Driver\AnnotationExporter::class
]; ];
/** /**

12
lib/Doctrine/ORM/Tools/Pagination/Paginator.php
View File

@ -142,9 +142,9 @@ class Paginator implements \Countable, \IteratorAggregate
$subQuery = $this->cloneQuery($this->query); $subQuery = $this->cloneQuery($this->query);
if ($this->useOutputWalker($subQuery)) { if ($this->useOutputWalker($subQuery)) {
$subQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, 'Doctrine\ORM\Tools\Pagination\LimitSubqueryOutputWalker'); $subQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, LimitSubqueryOutputWalker::class);
} else { } else {
$this->appendTreeWalker($subQuery, 'Doctrine\ORM\Tools\Pagination\LimitSubqueryWalker'); $this->appendTreeWalker($subQuery, LimitSubqueryWalker::class);
} }
$subQuery->setFirstResult($offset)->setMaxResults($length); $subQuery->setFirstResult($offset)->setMaxResults($length);
@ -154,10 +154,10 @@ class Paginator implements \Countable, \IteratorAggregate
$whereInQuery = $this->cloneQuery($this->query); $whereInQuery = $this->cloneQuery($this->query);
// don't do this for an empty id array // don't do this for an empty id array
if (count($ids) === 0) { if (count($ids) === 0) {
return new \ArrayIterator(array()); return new \ArrayIterator([]);
} }
$this->appendTreeWalker($whereInQuery, 'Doctrine\ORM\Tools\Pagination\WhereInWalker'); $this->appendTreeWalker($whereInQuery, WhereInWalker::class);
$whereInQuery->setHint(WhereInWalker::HINT_PAGINATOR_ID_COUNT, count($ids)); $whereInQuery->setHint(WhereInWalker::HINT_PAGINATOR_ID_COUNT, count($ids));
$whereInQuery->setFirstResult(null)->setMaxResults(null); $whereInQuery->setFirstResult(null)->setMaxResults(null);
$whereInQuery->setParameter(WhereInWalker::PAGINATOR_ID_ALIAS, $ids); $whereInQuery->setParameter(WhereInWalker::PAGINATOR_ID_ALIAS, $ids);
@ -252,10 +252,10 @@ class Paginator implements \Countable, \IteratorAggregate
$rsm = new ResultSetMapping(); $rsm = new ResultSetMapping();
$rsm->addScalarResult($platform->getSQLResultCasing('dctrn_count'), 'count'); $rsm->addScalarResult($platform->getSQLResultCasing('dctrn_count'), 'count');
$countQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, 'Doctrine\ORM\Tools\Pagination\CountOutputWalker'); $countQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, CountOutputWalker::class);
$countQuery->setResultSetMapping($rsm); $countQuery->setResultSetMapping($rsm);
} else { } else {
$this->appendTreeWalker($countQuery, 'Doctrine\ORM\Tools\Pagination\CountWalker'); $this->appendTreeWalker($countQuery, CountWalker::class);
} }
$countQuery->setFirstResult(null)->setMaxResults(null); $countQuery->setFirstResult(null)->setMaxResults(null);