vendor/gedmo/doctrine-extensions/src/Mapping/Driver/AbstractAnnotationDriver.php line 148

  1. <?php
  3. /*
  4.  * This file is part of the Doctrine Behavioral Extensions package.
  5.  * (c) Gediminas Morkevicius <gediminas.morkevicius@gmail.com> http://www.gediminasm.org
  6.  * For the full copyright and license information, please view the LICENSE
  7.  * file that was distributed with this source code.
  8.  */
  10. namespace Gedmo\Mapping\Driver;
  12. use Doctrine\Common\Annotations\Reader;
  13. use Doctrine\Deprecations\Deprecation;
  14. use Doctrine\Persistence\Mapping\ClassMetadata;
  15. use Doctrine\Persistence\Mapping\Driver\MappingDriver;
  17. /**
  18.  * This is an abstract class to implement common functionality
  19.  * for extension annotation mapping drivers.
  20.  *
  21.  * @author Derek J. Lambert <dlambert@dereklambert.com>
  22.  */
  23. abstract class AbstractAnnotationDriver implements AttributeDriverInterface
  24. {
  25.     /**
  26.      * Annotation reader instance
  27.      *
  28.      * @var Reader|AttributeReader|object
  29.      *
  30.      * @todo Remove the support for the `object` type in the next major release.
  31.      */
  32.     protected $reader;
  34.     /**
  35.      * Original driver if it is available
  36.      *
  37.      * @var MappingDriver
  38.      */
  39.     protected $_originalDriver;
  41.     /**
  42.      * List of types which are valid for extension
  43.      *
  44.      * @var string[]
  45.      */
  46.     protected $validTypes = [];
  48.     /**
  49.      * Set the annotation reader instance
  50.      *
  51.      * When originally implemented, `Doctrine\Common\Annotations\Reader` was not available,
  52.      * therefore this method may accept any object implementing these methods from the interface:
  53.      *
  54.      *     getClassAnnotations([reflectionClass])
  55.      *     getClassAnnotation([reflectionClass], [name])
  56.      *     getPropertyAnnotations([reflectionProperty])
  57.      *     getPropertyAnnotation([reflectionProperty], [name])
  58.      *
  59.      * @param Reader|AttributeReader|object $reader
  60.      *
  61.      * @return void
  62.      *
  63.      * @note Providing any object is deprecated, as of 4.0 an {@see AttributeReader} will be required
  64.      */
  65.     public function setAnnotationReader($reader)
  66.     {
  67.         if ($reader instanceof Reader) {
  68.             Deprecation::trigger(
  69.                 'gedmo/doctrine-extensions',
  70.                 'https://github.com/doctrine-extensions/DoctrineExtensions/pull/2772',
  71.                 'Annotations support is deprecated, migrate your application to use attributes and pass an instance of %s to the %s() method instead.',
  72.                 AttributeReader::class,
  73.                 __METHOD__
  74.             );
  75.         } elseif (!$reader instanceof AttributeReader) {
  76.             Deprecation::trigger(
  77.                 'gedmo/doctrine-extensions',
  78.                 'https://github.com/doctrine-extensions/DoctrineExtensions/pull/2558',
  79.                 'Providing an annotation reader which does not implement %s or is not an instance of %s to %s() is deprecated.',
  80.                 Reader::class,
  81.                 AttributeReader::class,
  82.                 __METHOD__
  83.             );
  84.         }
  86.         $this->reader = $reader;
  87.     }
  89.     /**
  90.      * Passes in the mapping read by original driver
  91.      *
  92.      * @param MappingDriver $driver
  93.      *
  94.      * @return void
  95.      */
  96.     public function setOriginalDriver($driver)
  97.     {
  98.         $this->_originalDriver = $driver;
  99.     }
  101.     /**
  102.      * @param ClassMetadata<object> $meta
  103.      *
  104.      * @return \ReflectionClass<object>
  105.      */
  106.     public function getMetaReflectionClass($meta)
  107.     {
  108.         return $meta->getReflectionClass();
  109.     }
  111.     /**
  112.      * @param ClassMetadata<object> $meta
  113.      * @param array<string, mixed>  $config
  114.      *
  115.      * @return void
  116.      */
  117.     public function validateFullMetadata(ClassMetadata $meta, array $config)
  118.     {
  119.     }
  121.     /**
  122.      * Checks if $field type is valid
  123.      *
  124.      * @param ClassMetadata<object> $meta
  125.      * @param string                $field
  126.      *
  127.      * @return bool
  128.      */
  129.     protected function isValidField($meta, $field)
  130.     {
  131.         $mapping = $meta->getFieldMapping($field);
  133.         return $mapping && in_array($mapping->type ?? $mapping['type'], $this->validTypes, true);
  134.     }
  136.     /**
  137.      * Try to find out related class name out of mapping
  138.      *
  139.      * @param ClassMetadata<object> $metadata the mapped class metadata
  140.      * @param string                $name     the related object class name
  141.      *
  142.      * @return string related class name or empty string if does not exist
  143.      *
  144.      * @phpstan-param class-string|string $name
  145.      *
  146.      * @phpstan-return class-string|''
  147.      */
  148.     protected function getRelatedClassName($metadata, $name)
  149.     {
  150.         if (class_exists($name) || interface_exists($name)) {
  151.             return $name;
  152.         }
  153.         $refl = $metadata->getReflectionClass();
  154.         $ns = $refl->getNamespaceName();
  155.         $className = $ns.'\\'.$name;
  157.         return class_exists($className) ? $className : '';
  158.     }
  159. }