Gecko [ v3.cesa.co.za ]

Name	Size	Permission	Date
Cache	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Decorator	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Event	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Exception	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Id	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Internal	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Mapping	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Persisters	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Proxy	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Query	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Repository	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Tools	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
Utility	[ DIR ]	drwxrwxr-x	2026-08-17 03:12
.htaccess	237 B	-r-xr-xr-x	2026-08-17 03:12
AbstractQuery.php	40.83 KB	-rwxrwxr-x	2026-04-02 06:18
Cache.php	4.71 KB	-rwxrwxr-x	2026-04-02 06:18
Configuration.php	35.73 KB	-rwxrwxr-x	2026-04-02 06:18
EntityManager.php	31.96 KB	-rwxrwxr-x	2026-04-02 06:18
EntityManagerInterface.php	9.59 KB	-rwxrwxr-x	2026-04-02 06:18
EntityNotFoundException.php	1.06 KB	-rwxrwxr-x	2026-04-02 06:18
EntityRepository.php	10.99 KB	-rwxrwxr-x	2026-04-02 06:18
Events.php	3.93 KB	-rwxrwxr-x	2026-04-02 06:18
LazyCriteriaCollection.php	2.88 KB	-rwxrwxr-x	2026-04-02 06:18
NativeQuery.php	1.76 KB	-rwxrwxr-x	2026-04-02 06:18
NoResultException.php	356 B	-rwxrwxr-x	2026-04-02 06:18
NonUniqueResultException.php	468 B	-rwxrwxr-x	2026-04-02 06:18
ORMException.php	8.82 KB	-rwxrwxr-x	2026-04-02 06:18
ORMInvalidArgumentException.php	10.34 KB	-rwxrwxr-x	2026-04-02 06:18
ORMSetup.php	6.88 KB	-rwxrwxr-x	2026-04-02 06:18
OptimisticLockException.php	2.03 KB	-rwxrwxr-x	2026-04-02 06:18
PersistentCollection.php	21.18 KB	-rwxrwxr-x	2026-04-02 06:18
PessimisticLockException.php	309 B	-rwxrwxr-x	2026-04-02 06:18
Query.php	24.43 KB	-rwxrwxr-x	2026-04-02 06:18
QueryBuilder.php	44.52 KB	-rwxrwxr-x	2026-04-02 06:18
TransactionRequiredException.php	496 B	-rwxrwxr-x	2026-04-02 06:18
UnexpectedResultException.php	209 B	-rwxrwxr-x	2026-04-02 06:18
UnitOfWork.php	145.19 KB	-rwxrwxr-x	2026-04-02 06:18
Version.php	962 B	-rwxrwxr-x	2026-04-02 06:18

Rename

<?php

declare(strict_types=1);

namespace Doctrine\ORM;

use Doctrine\Deprecations\Deprecation;
use Doctrine\ORM\Mapping\ClassMetadata;
use InvalidArgumentException;

use function array_map;
use function count;
use function func_get_arg;
use function func_num_args;
use function get_debug_type;
use function gettype;
use function implode;
use function is_scalar;
use function method_exists;
use function reset;
use function spl_object_id;
use function sprintf;

/**
 * Contains exception messages for all invalid lifecycle state exceptions inside UnitOfWork
 *
 * @phpstan-import-type AssociationMapping from ClassMetadata
 */
class ORMInvalidArgumentException extends InvalidArgumentException
{
    /**
     * @param object $entity
     *
     * @return ORMInvalidArgumentException
     */
    public static function scheduleInsertForManagedEntity($entity)
    {
        return new self('A managed+dirty entity ' . self::objToStr($entity) . ' can not be scheduled for insertion.');
    }

/**
     * @param object $entity
     *
     * @return ORMInvalidArgumentException
     */
    public static function scheduleInsertForRemovedEntity($entity)
    {
        return new self('Removed entity ' . self::objToStr($entity) . ' can not be scheduled for insertion.');
    }

/**
     * @param object $entity
     *
     * @return ORMInvalidArgumentException
     */
    public static function scheduleInsertTwice($entity)
    {
        return new self('Entity ' . self::objToStr($entity) . ' can not be scheduled for insertion twice.');
    }

/**
     * @param string $className
     * @param object $entity
     *
     * @return ORMInvalidArgumentException
     */
    public static function entityWithoutIdentity($className, $entity)
    {
        return new self(
            "The given entity of type '" . $className . "' (" . self::objToStr($entity) . ') has no identity/no ' .
            'id values set. It cannot be added to the identity map.'
        );
    }

/**
     * @param object $entity
     *
     * @return ORMInvalidArgumentException
     */
    public static function readOnlyRequiresManagedEntity($entity)
    {
        return new self('Only managed entities can be marked or checked as read only. But ' . self::objToStr($entity) . ' is not');
    }

/**
     * @phpstan-param non-empty-list<array{AssociationMapping, object}> $newEntitiesWithAssociations non-empty an array
     *                                                                of [array $associationMapping, object $entity] pairs
     *
     * @return ORMInvalidArgumentException
     */
    public static function newEntitiesFoundThroughRelationships($newEntitiesWithAssociations)
    {
        $errorMessages = array_map(
            static function (array $newEntityWithAssociation): string {
                [$associationMapping, $entity] = $newEntityWithAssociation;

return self::newEntityFoundThroughRelationshipMessage($associationMapping, $entity);
            },
            $newEntitiesWithAssociations
        );

if (count($errorMessages) === 1) {
            return new self(reset($errorMessages));
        }

return new self(
            'Multiple non-persisted new entities were found through the given association graph:'
            . "\n\n * "
            . implode("\n * ", $errorMessages)
        );
    }

/**
     * @param object $entry
     * @phpstan-param AssociationMapping $associationMapping
     *
     * @return ORMInvalidArgumentException
     */
    public static function newEntityFoundThroughRelationship(array $associationMapping, $entry)
    {
        return new self(self::newEntityFoundThroughRelationshipMessage($associationMapping, $entry));
    }

/**
     * @param object $entry
     * @phpstan-param AssociationMapping $assoc
     *
     * @return ORMInvalidArgumentException
     */
    public static function detachedEntityFoundThroughRelationship(array $assoc, $entry)
    {
        return new self('A detached entity of type ' . $assoc['targetEntity'] . ' (' . self::objToStr($entry) . ') '
            . " was found through the relationship '" . $assoc['sourceEntity'] . '#' . $assoc['fieldName'] . "' "
            . 'during cascading a persist operation.');
    }

/**
     * @param object $entity
     *
     * @return ORMInvalidArgumentException
     */
    public static function entityNotManaged($entity)
    {
        return new self('Entity ' . self::objToStr($entity) . ' is not managed. An entity is managed if its fetched ' .
            'from the database or registered as new through EntityManager#persist');
    }

/**
     * @param object $entity
     * @param string $operation
     *
     * @return ORMInvalidArgumentException
     */
    public static function entityHasNoIdentity($entity, $operation)
    {
        return new self('Entity has no identity, therefore ' . $operation . ' cannot be performed. ' . self::objToStr($entity));
    }

/**
     * @param object $entity
     * @param string $operation
     *
     * @return ORMInvalidArgumentException
     */
    public static function entityIsRemoved($entity, $operation)
    {
        return new self('Entity is removed, therefore ' . $operation . ' cannot be performed. ' . self::objToStr($entity));
    }

/**
     * @param object $entity
     * @param string $operation
     *
     * @return ORMInvalidArgumentException
     */
    public static function detachedEntityCannot($entity, $operation)
    {
        return new self('Detached entity ' . self::objToStr($entity) . ' cannot be ' . $operation);
    }

/**
     * @param string $context
     * @param mixed  $given
     * @param int    $parameterIndex
     *
     * @return ORMInvalidArgumentException
     */
    public static function invalidObject($context, $given, $parameterIndex = 1)
    {
        return new self($context . ' expects parameter ' . $parameterIndex .
            ' to be an entity object, ' . gettype($given) . ' given.');
    }

/** @return ORMInvalidArgumentException */
    public static function invalidCompositeIdentifier()
    {
        return new self('Binding an entity with a composite primary key to a query is not supported. ' .
            'You should split the parameter into the explicit fields and bind them separately.');
    }

/** @return ORMInvalidArgumentException */
    public static function invalidIdentifierBindingEntity(/* string $class */)
    {
        if (func_num_args() === 0) {
            Deprecation::trigger(
                'doctrine/orm',
                'https://github.com/doctrine/orm/pull/9642',
                'Omitting the class name in the exception method %s is deprecated.',
                __METHOD__
            );

return new self('Binding entities to query parameters only allowed for entities that have an identifier.');
        }

return new self(sprintf(
            <<<'EXCEPTION'
Binding entities to query parameters only allowed for entities that have an identifier.
Class "%s" does not have an identifier.
EXCEPTION
            ,
            func_get_arg(0)
        ));
    }

/**
     * @param AssociationMapping $assoc
     * @param mixed              $actualValue
     *
     * @return self
     */
    public static function invalidAssociation(ClassMetadata $targetClass, $assoc, $actualValue)
    {
        $expectedType = $targetClass->getName();

return new self(sprintf(
            'Expected value of type "%s" for association field "%s#$%s", got "%s" instead.',
            $expectedType,
            $assoc['sourceEntity'],
            $assoc['fieldName'],
            get_debug_type($actualValue)
        ));
    }

/**
     * Used when a given entityName hasn't the good type
     *
     * @deprecated This method will be removed in 3.0.
     *
     * @param mixed $entityName The given entity (which shouldn't be a string)
     *
     * @return self
     */
    public static function invalidEntityName($entityName)
    {
        Deprecation::triggerIfCalledFromOutside(
            'doctrine/orm',
            'https://github.com/doctrine/orm/pull/9471',
            '%s() is deprecated',
            __METHOD__
        );

return new self(sprintf('Entity name must be a string, %s given', get_debug_type($entityName)));
    }

/** @param mixed $value */
    public static function invalidAutoGenerateMode($value): self
    {
        return new self(sprintf('Invalid auto generate mode "%s" given.', is_scalar($value) ? (string) $value : get_debug_type($value)));
    }

public static function missingPrimaryKeyValue(string $className, string $idField): self
    {
        return new self(sprintf('Missing value for primary key %s on %s', $idField, $className));
    }

public static function proxyDirectoryRequired(): self
    {
        return new self('You must configure a proxy directory. See docs for details');
    }

public static function proxyNamespaceRequired(): self
    {
        return new self('You must configure a proxy namespace');
    }

public static function proxyDirectoryNotWritable(string $proxyDirectory): self
    {
        return new self(sprintf('Your proxy directory "%s" must be writable', $proxyDirectory));
    }

/**
     * Helper method to show an object as string.
     *
     * @param object $obj
     */
    private static function objToStr($obj): string
    {
        return method_exists($obj, '__toString') ? (string) $obj : get_debug_type($obj) . '@' . spl_object_id($obj);
    }

/**
     * @param object $entity
     * @phpstan-param AssociationMapping $associationMapping
     */
    private static function newEntityFoundThroughRelationshipMessage(array $associationMapping, $entity): string
    {
        return 'A new entity was found through the relationship \''
            . $associationMapping['sourceEntity'] . '#' . $associationMapping['fieldName'] . '\' that was not'
            . ' configured to cascade persist operations for entity: ' . self::objToStr($entity) . '.'
            . ' To solve this issue: Either explicitly call EntityManager#persist()'
            . ' on this unknown entity or configure cascade persist'
            . ' this association in the mapping for example #[ORM\ManyToOne(..., cascade: [\'persist\'])].'
            . (method_exists($entity, '__toString')
                ? ''
                : ' If you cannot find out which entity causes the problem implement \''
                . $associationMapping['targetEntity'] . '#__toString()\' to get a clue.'
            );
    }
}