vendor/doctrine/orm/lib/Doctrine/ORM/ORMInvalidArgumentException.php line 185

  1. <?php
  3. declare(strict_types=1);
  5. namespace Doctrine\ORM;
  7. use Doctrine\Deprecations\Deprecation;
  8. use Doctrine\ORM\Mapping\ClassMetadata;
  9. use InvalidArgumentException;
  11. use function array_map;
  12. use function count;
  13. use function func_get_arg;
  14. use function func_num_args;
  15. use function get_debug_type;
  16. use function gettype;
  17. use function implode;
  18. use function method_exists;
  19. use function reset;
  20. use function spl_object_id;
  21. use function sprintf;
  23. /**
  24.  * Contains exception messages for all invalid lifecycle state exceptions inside UnitOfWork
  25.  */
  26. class ORMInvalidArgumentException extends InvalidArgumentException
  27. {
  28.     /**
  29.      * @param object $entity
  30.      *
  31.      * @return ORMInvalidArgumentException
  32.      */
  33.     public static function scheduleInsertForManagedEntity($entity)
  34.     {
  35.         return new self('A managed+dirty entity ' . self::objToStr($entity) . ' can not be scheduled for insertion.');
  36.     }
  38.     /**
  39.      * @param object $entity
  40.      *
  41.      * @return ORMInvalidArgumentException
  42.      */
  43.     public static function scheduleInsertForRemovedEntity($entity)
  44.     {
  45.         return new self('Removed entity ' . self::objToStr($entity) . ' can not be scheduled for insertion.');
  46.     }
  48.     /**
  49.      * @param object $entity
  50.      *
  51.      * @return ORMInvalidArgumentException
  52.      */
  53.     public static function scheduleInsertTwice($entity)
  54.     {
  55.         return new self('Entity ' . self::objToStr($entity) . ' can not be scheduled for insertion twice.');
  56.     }
  58.     /**
  59.      * @param string $className
  60.      * @param object $entity
  61.      *
  62.      * @return ORMInvalidArgumentException
  63.      */
  64.     public static function entityWithoutIdentity($className, $entity)
  65.     {
  66.         return new self(
  67.             "The given entity of type '" . $className . "' (" . self::objToStr($entity) . ') has no identity/no ' .
  68.             'id values set. It cannot be added to the identity map.'
  69.         );
  70.     }
  72.     /**
  73.      * @param object $entity
  74.      *
  75.      * @return ORMInvalidArgumentException
  76.      */
  77.     public static function readOnlyRequiresManagedEntity($entity)
  78.     {
  79.         return new self('Only managed entities can be marked or checked as read only. But ' . self::objToStr($entity) . ' is not');
  80.     }
  82.     /**
  83.      * @param array[][]|object[][] $newEntitiesWithAssociations non-empty an array
  84.      *                                                              of [array $associationMapping, object $entity] pairs
  85.      *
  86.      * @return ORMInvalidArgumentException
  87.      */
  88.     public static function newEntitiesFoundThroughRelationships($newEntitiesWithAssociations)
  89.     {
  90.         $errorMessages = array_map(
  91.             static function (array $newEntityWithAssociation): string {
  92.                 [$associationMapping, $entity] = $newEntityWithAssociation;
  94.                 return self::newEntityFoundThroughRelationshipMessage($associationMapping, $entity);
  95.             },
  96.             $newEntitiesWithAssociations
  97.         );
  99.         if (count($errorMessages) === 1) {
  100.             return new self(reset($errorMessages));
  101.         }
  103.         return new self(
  104.             'Multiple non-persisted new entities were found through the given association graph:'
  105.             . "\n\n * "
  106.             . implode("\n * ", $errorMessages)
  107.         );
  108.     }
  110.     /**
  111.      * @param object $entry
  112.      * @psalm-param array<string, string> $associationMapping
  113.      *
  114.      * @return ORMInvalidArgumentException
  115.      */
  116.     public static function newEntityFoundThroughRelationship(array $associationMapping, $entry)
  117.     {
  118.         return new self(self::newEntityFoundThroughRelationshipMessage($associationMapping, $entry));
  119.     }
  121.     /**
  122.      * @param object $entry
  123.      * @psalm-param array<string, string> $assoc
  124.      *
  125.      * @return ORMInvalidArgumentException
  126.      */
  127.     public static function detachedEntityFoundThroughRelationship(array $assoc, $entry)
  128.     {
  129.         return new self('A detached entity of type ' . $assoc['targetEntity'] . ' (' . self::objToStr($entry) . ') '
  130.             . " was found through the relationship '" . $assoc['sourceEntity'] . '#' . $assoc['fieldName'] . "' "
  131.             . 'during cascading a persist operation.');
  132.     }
  134.     /**
  135.      * @param object $entity
  136.      *
  137.      * @return ORMInvalidArgumentException
  138.      */
  139.     public static function entityNotManaged($entity)
  140.     {
  141.         return new self('Entity ' . self::objToStr($entity) . ' is not managed. An entity is managed if its fetched ' .
  142.             'from the database or registered as new through EntityManager#persist');
  143.     }
  145.     /**
  146.      * @param object $entity
  147.      * @param string $operation
  148.      *
  149.      * @return ORMInvalidArgumentException
  150.      */
  151.     public static function entityHasNoIdentity($entity, $operation)
  152.     {
  153.         return new self('Entity has no identity, therefore ' . $operation . ' cannot be performed. ' . self::objToStr($entity));
  154.     }
  156.     /**
  157.      * @param object $entity
  158.      * @param string $operation
  159.      *
  160.      * @return ORMInvalidArgumentException
  161.      */
  162.     public static function entityIsRemoved($entity, $operation)
  163.     {
  164.         return new self('Entity is removed, therefore ' . $operation . ' cannot be performed. ' . self::objToStr($entity));
  165.     }
  167.     /**
  168.      * @param object $entity
  169.      * @param string $operation
  170.      *
  171.      * @return ORMInvalidArgumentException
  172.      */
  173.     public static function detachedEntityCannot($entity, $operation)
  174.     {
  175.         return new self('Detached entity ' . self::objToStr($entity) . ' cannot be ' . $operation);
  176.     }
  178.     /**
  179.      * @param string $context
  180.      * @param mixed  $given
  181.      * @param int    $parameterIndex
  182.      *
  183.      * @return ORMInvalidArgumentException
  184.      */
  185.     public static function invalidObject($context, $given, $parameterIndex = 1)
  186.     {
  187.         return new self($context . ' expects parameter ' . $parameterIndex .
  188.             ' to be an entity object, ' . gettype($given) . ' given.');
  189.     }
  191.     /** @return ORMInvalidArgumentException */
  192.     public static function invalidCompositeIdentifier()
  193.     {
  194.         return new self('Binding an entity with a composite primary key to a query is not supported. ' .
  195.             'You should split the parameter into the explicit fields and bind them separately.');
  196.     }
  198.     /** @return ORMInvalidArgumentException */
  199.     public static function invalidIdentifierBindingEntity(/* string $class */)
  200.     {
  201.         if (func_num_args() === 0) {
  202.             Deprecation::trigger(
  203.                 'doctrine/orm',
  204.                 'https://github.com/doctrine/orm/pull/9642',
  205.                 'Omitting the class name in the exception method %s is deprecated.',
  206.                 __METHOD__
  207.             );
  209.             return new self('Binding entities to query parameters only allowed for entities that have an identifier.');
  210.         }
  212.         return new self(sprintf(
  213.             <<<'EXCEPTION'
  214. Binding entities to query parameters only allowed for entities that have an identifier.
  215. Class "%s" does not have an identifier.
  216. EXCEPTION
  217.             ,
  218.             func_get_arg(0)
  219.         ));
  220.     }
  222.     /**
  223.      * @param mixed[] $assoc
  224.      * @param mixed   $actualValue
  225.      *
  226.      * @return self
  227.      */
  228.     public static function invalidAssociation(ClassMetadata $targetClass, $assoc, $actualValue)
  229.     {
  230.         $expectedType = $targetClass->getName();
  232.         return new self(sprintf(
  233.             'Expected value of type "%s" for association field "%s#$%s", got "%s" instead.',
  234.             $expectedType,
  235.             $assoc['sourceEntity'],
  236.             $assoc['fieldName'],
  237.             get_debug_type($actualValue)
  238.         ));
  239.     }
  241.     /**
  242.      * Used when a given entityName hasn't the good type
  243.      *
  244.      * @deprecated This method will be removed in 3.0.
  245.      *
  246.      * @param mixed $entityName The given entity (which shouldn't be a string)
  247.      *
  248.      * @return self
  249.      */
  250.     public static function invalidEntityName($entityName)
  251.     {
  252.         Deprecation::triggerIfCalledFromOutside(
  253.             'doctrine/orm',
  254.             'https://github.com/doctrine/orm/pull/9471',
  255.             '%s() is deprecated',
  256.             __METHOD__
  257.         );
  259.         return new self(sprintf('Entity name must be a string, %s given', get_debug_type($entityName)));
  260.     }
  262.     /**
  263.      * Helper method to show an object as string.
  264.      *
  265.      * @param object $obj
  266.      */
  267.     private static function objToStr($obj): string
  268.     {
  269.         return method_exists($obj, '__toString') ? (string) $obj : get_debug_type($obj) . '@' . spl_object_id($obj);
  270.     }
  272.     /**
  273.      * @param object $entity
  274.      * @psalm-param array<string,string> $associationMapping
  275.      */
  276.     private static function newEntityFoundThroughRelationshipMessage(array $associationMapping, $entity): string
  277.     {
  278.         return 'A new entity was found through the relationship \''
  279.             . $associationMapping['sourceEntity'] . '#' . $associationMapping['fieldName'] . '\' that was not'
  280.             . ' configured to cascade persist operations for entity: ' . self::objToStr($entity) . '.'
  281.             . ' To solve this issue: Either explicitly call EntityManager#persist()'
  282.             . ' on this unknown entity or configure cascade persist'
  283.             . ' this association in the mapping for example @ManyToOne(..,cascade={"persist"}).'
  284.             . (method_exists($entity, '__toString')
  285.                 ? ''
  286.                 : ' If you cannot find out which entity causes the problem implement \''
  287.                 . $associationMapping['targetEntity'] . '#__toString()\' to get a clue.'
  288.             );
  289.     }
  290. }