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

Open in your IDE?
  1. <?php
  2. /*
  3.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  4.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  5.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  6.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  7.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  8.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  9.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  10.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  11.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  12.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  13.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  14.  *
  15.  * This software consists of voluntary contributions made by many individuals
  16.  * and is licensed under the MIT license. For more information, see
  17.  * <http://www.doctrine-project.org>.
  18.  */
  20. namespace Doctrine\ORM;
  21. use Doctrine\ORM\Mapping\ClassMetadata;
  23. /**
  24.  * Contains exception messages for all invalid lifecycle state exceptions inside UnitOfWork
  25.  *
  26.  * @author Benjamin Eberlei <kontakt@beberlei.de>
  27.  */
  28. class ORMInvalidArgumentException extends \InvalidArgumentException
  29. {
  30.     /**
  31.      * @param object $entity
  32.      *
  33.      * @return ORMInvalidArgumentException
  34.      */
  35.     static public function scheduleInsertForManagedEntity($entity)
  36.     {
  37.         return new self("A managed+dirty entity " . self::objToStr($entity) . " can not be scheduled for insertion.");
  38.     }
  40.     /**
  41.      * @param object $entity
  42.      *
  43.      * @return ORMInvalidArgumentException
  44.      */
  45.     static public function scheduleInsertForRemovedEntity($entity)
  46.     {
  47.         return new self("Removed entity " . self::objToStr($entity) . " can not be scheduled for insertion.");
  48.     }
  50.     /**
  51.      * @param object $entity
  52.      *
  53.      * @return ORMInvalidArgumentException
  54.      */
  55.     static public function scheduleInsertTwice($entity)
  56.     {
  57.         return new self("Entity " . self::objToStr($entity) . " can not be scheduled for insertion twice.");
  58.     }
  60.     /**
  61.      * @param string $className
  62.      * @param object $entity
  63.      *
  64.      * @return ORMInvalidArgumentException
  65.      */
  66.     static public function entityWithoutIdentity($className, $entity)
  67.     {
  68.         return new self(
  69.             "The given entity of type '" . $className . "' (".self::objToStr($entity).") has no identity/no " .
  70.             "id values set. It cannot be added to the identity map."
  71.         );
  72.     }
  74.     /**
  75.      * @param object $entity
  76.      *
  77.      * @return ORMInvalidArgumentException
  78.      */
  79.     static public function readOnlyRequiresManagedEntity($entity)
  80.     {
  81.         return new self("Only managed entities can be marked or checked as read only. But " . self::objToStr($entity) . " is not");
  82.     }
  84.     /**
  85.      * @param array[][]|object[][] $newEntitiesWithAssociations non-empty an array
  86.  *                                                              of [array $associationMapping, object $entity] pairs
  87.      *
  88.      * @return ORMInvalidArgumentException
  89.      */
  90.     static public function newEntitiesFoundThroughRelationships($newEntitiesWithAssociations)
  91.     {
  92.         $errorMessages = array_map(
  93.             function (array $newEntityWithAssociation) : string {
  94.                 [$associationMapping, $entity] = $newEntityWithAssociation;
  96.                 return self::newEntityFoundThroughRelationshipMessage($associationMapping, $entity);
  97.             },
  98.             $newEntitiesWithAssociations
  99.         );
  101.         if (1 === count($errorMessages)) {
  102.             return new self(reset($errorMessages));
  103.         }
  105.         return new self(
  106.             'Multiple non-persisted new entities were found through the given association graph:'
  107.             . "\n\n * "
  108.             . implode("\n * ", $errorMessages)
  109.         );
  110.     }
  112.     /**
  113.      * @param array  $associationMapping
  114.      * @param object $entry
  115.      *
  116.      * @return ORMInvalidArgumentException
  117.      */
  118.     static public function newEntityFoundThroughRelationship(array $associationMapping, $entry)
  119.     {
  120.         return new self(self::newEntityFoundThroughRelationshipMessage($associationMapping, $entry));
  121.     }
  123.     /**
  124.      * @param array  $assoc
  125.      * @param object $entry
  126.      *
  127.      * @return ORMInvalidArgumentException
  128.      */
  129.     static public function detachedEntityFoundThroughRelationship(array $assoc, $entry)
  130.     {
  131.         return new self("A detached entity of type " . $assoc['targetEntity'] . " (" . self::objToStr($entry) . ") "
  132.             . " was found through the relationship '" . $assoc['sourceEntity'] . "#" . $assoc['fieldName'] . "' "
  133.             . "during cascading a persist operation.");
  134.     }
  136.     /**
  137.      * @param object $entity
  138.      *
  139.      * @return ORMInvalidArgumentException
  140.      */
  141.     static public function entityNotManaged($entity)
  142.     {
  143.         return new self("Entity " . self::objToStr($entity) . " is not managed. An entity is managed if its fetched " .
  144.             "from the database or registered as new through EntityManager#persist");
  145.     }
  147.     /**
  148.      * @param object $entity
  149.      * @param string $operation
  150.      *
  151.      * @return ORMInvalidArgumentException
  152.      */
  153.     static public function entityHasNoIdentity($entity, $operation)
  154.     {
  155.         return new self("Entity has no identity, therefore " . $operation ." cannot be performed. " . self::objToStr($entity));
  156.     }
  158.     /**
  159.      * @param object $entity
  160.      * @param string $operation
  161.      *
  162.      * @return ORMInvalidArgumentException
  163.      */
  164.     static public function entityIsRemoved($entity, $operation)
  165.     {
  166.         return new self("Entity is removed, therefore " . $operation ." cannot be performed. " . self::objToStr($entity));
  167.     }
  169.     /**
  170.      * @param object $entity
  171.      * @param string $operation
  172.      *
  173.      * @return ORMInvalidArgumentException
  174.      */
  175.     static public function detachedEntityCannot($entity, $operation)
  176.     {
  177.         return new self("Detached entity " . self::objToStr($entity) . " cannot be " . $operation);
  178.     }
  180.     /**
  181.      * @param string $context
  182.      * @param mixed  $given
  183.      * @param int    $parameterIndex
  184.      *
  185.      * @return ORMInvalidArgumentException
  186.      */
  187.     public static function invalidObject($context, $given, $parameterIndex = 1)
  188.     {
  189.         return new self($context . ' expects parameter ' . $parameterIndex .
  190.             ' to be an entity object, '. gettype($given) . ' given.');
  191.     }
  193.     /**
  194.      * @return ORMInvalidArgumentException
  195.      */
  196.     public static function invalidCompositeIdentifier()
  197.     {
  198.         return new self("Binding an entity with a composite primary key to a query is not supported. " .
  199.             "You should split the parameter into the explicit fields and bind them separately.");
  200.     }
  202.     /**
  203.      * @return ORMInvalidArgumentException
  204.      */
  205.     public static function invalidIdentifierBindingEntity()
  206.     {
  207.         return new self("Binding entities to query parameters only allowed for entities that have an identifier.");
  208.     }
  210.     /**
  211.      * @param ClassMetadata $targetClass
  212.      * @param array         $assoc
  213.      * @param mixed         $actualValue
  214.      *
  215.      * @return self
  216.      */
  217.     public static function invalidAssociation(ClassMetadata $targetClass, $assoc, $actualValue)
  218.     {
  219.         $expectedType = $targetClass->getName();
  221.         return new self(sprintf(
  222.             'Expected value of type "%s" for association field "%s#$%s", got "%s" instead.',
  223.             $expectedType,
  224.             $assoc['sourceEntity'],
  225.             $assoc['fieldName'],
  226.             is_object($actualValue) ? get_class($actualValue) : gettype($actualValue)
  227.         ));
  228.     }
  230.     /**
  231.      * Used when a given entityName hasn't the good type
  232.      *
  233.      * @param mixed $entityName The given entity (which shouldn't be a string)
  234.      *
  235.      * @return self
  236.      */
  237.     public static function invalidEntityName($entityName)
  238.     {
  239.         return new self(sprintf('Entity name must be a string, %s given', gettype($entityName)));
  240.     }
  242.     /**
  243.      * Helper method to show an object as string.
  244.      *
  245.      * @param object $obj
  246.      *
  247.      * @return string
  248.      */
  249.     private static function objToStr($obj) : string
  250.     {
  251.         return method_exists($obj, '__toString') ? (string) $obj : get_class($obj).'@'.spl_object_hash($obj);
  252.     }
  254.     /**
  255.      * @param array  $associationMapping
  256.      * @param object $entity
  257.      */
  258.     private static function newEntityFoundThroughRelationshipMessage(array $associationMapping, $entity) : string
  259.     {
  260.         return 'A new entity was found through the relationship \''
  261.             . $associationMapping['sourceEntity'] . '#' . $associationMapping['fieldName'] . '\' that was not'
  262.             . ' configured to cascade persist operations for entity: ' . self::objToStr($entity) . '.'
  263.             . ' To solve this issue: Either explicitly call EntityManager#persist()'
  264.             . ' on this unknown entity or configure cascade persist'
  265.             . ' this association in the mapping for example @ManyToOne(..,cascade={"persist"}).'
  266.             . (method_exists($entity, '__toString')
  267.                 ? ''
  268.                 : ' If you cannot find out which entity causes the problem implement \''
  269.                 . $associationMapping['targetEntity'] . '#__toString()\' to get a clue.'
  270.             );
  271.     }
  272. }