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

Open in your IDE?
  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.     /**
  192.      * @return ORMInvalidArgumentException
  193.      */
  194.     public static function invalidCompositeIdentifier()
  195.     {
  196.         return new self('Binding an entity with a composite primary key to a query is not supported. ' .
  197.             'You should split the parameter into the explicit fields and bind them separately.');
  198.     }
  200.     /**
  201.      * @return ORMInvalidArgumentException
  202.      */
  203.     public static function invalidIdentifierBindingEntity(/* string $class */)
  204.     {
  205.         if (func_num_args() === 0) {
  206.             Deprecation::trigger(
  207.                 'doctrine/orm',
  208.                 'https://github.com/doctrine/orm/pull/9642',
  209.                 'Omitting the class name in the exception method %s is deprecated.',
  210.                 __METHOD__
  211.             );
  213.             return new self('Binding entities to query parameters only allowed for entities that have an identifier.');
  214.         }
  216.         return new self(sprintf(
  217.             <<<'EXCEPTION'
  218. Binding entities to query parameters only allowed for entities that have an identifier.
  219. Class "%s" does not have an identifier.
  220. EXCEPTION
  221.             ,
  222.             func_get_arg(0)
  223.         ));
  224.     }
  226.     /**
  227.      * @param mixed[] $assoc
  228.      * @param mixed   $actualValue
  229.      *
  230.      * @return self
  231.      */
  232.     public static function invalidAssociation(ClassMetadata $targetClass, $assoc, $actualValue)
  233.     {
  234.         $expectedType = $targetClass->getName();
  236.         return new self(sprintf(
  237.             'Expected value of type "%s" for association field "%s#$%s", got "%s" instead.',
  238.             $expectedType,
  239.             $assoc['sourceEntity'],
  240.             $assoc['fieldName'],
  241.             get_debug_type($actualValue)
  242.         ));
  243.     }
  245.     /**
  246.      * Used when a given entityName hasn't the good type
  247.      *
  248.      * @deprecated This method will be removed in 3.0.
  249.      *
  250.      * @param mixed $entityName The given entity (which shouldn't be a string)
  251.      *
  252.      * @return self
  253.      */
  254.     public static function invalidEntityName($entityName)
  255.     {
  256.         Deprecation::triggerIfCalledFromOutside(
  257.             'doctrine/orm',
  258.             'https://github.com/doctrine/orm/pull/9471',
  259.             '%s() is deprecated',
  260.             __METHOD__
  261.         );
  263.         return new self(sprintf('Entity name must be a string, %s given', get_debug_type($entityName)));
  264.     }
  266.     /**
  267.      * Helper method to show an object as string.
  268.      *
  269.      * @param object $obj
  270.      */
  271.     private static function objToStr($obj): string
  272.     {
  273.         return method_exists($obj, '__toString') ? (string) $obj : get_debug_type($obj) . '@' . spl_object_id($obj);
  274.     }
  276.     /**
  277.      * @param object $entity
  278.      * @psalm-param array<string,string> $associationMapping
  279.      */
  280.     private static function newEntityFoundThroughRelationshipMessage(array $associationMapping, $entity): string
  281.     {
  282.         return 'A new entity was found through the relationship \''
  283.             . $associationMapping['sourceEntity'] . '#' . $associationMapping['fieldName'] . '\' that was not'
  284.             . ' configured to cascade persist operations for entity: ' . self::objToStr($entity) . '.'
  285.             . ' To solve this issue: Either explicitly call EntityManager#persist()'
  286.             . ' on this unknown entity or configure cascade persist'
  287.             . ' this association in the mapping for example @ManyToOne(..,cascade={"persist"}).'
  288.             . (method_exists($entity, '__toString')
  289.                 ? ''
  290.                 : ' If you cannot find out which entity causes the problem implement \''
  291.                 . $associationMapping['targetEntity'] . '#__toString()\' to get a clue.'
  292.             );
  293.     }
  294. }