Class Doctrine\ORM\PersistentCollection

`<TKey is array-key, T>`

`final`
`extends`	`AbstractLazyCollection<TKey, T>`
`implements`	`Selectable<TKey, T>`

A PersistentCollection represents a collection of elements that have persistent state.

Collections of entities represent only the associations (links) to those entities. That means, if the collection is part of a many-many mapping and you remove entities from the collection, only the links in the relation table are removed (on flush). Similarly, if you remove entities from a collection that is part of a one-many mapping this will only result in the nulling out of the foreign keys on flush.

Doctrine\Common\Collections\AbstractLazyCollection implements Collection<TKey, T>
- Doctrine\ORM\PersistentCollection implements Selectable<TKey, T>

Methods


					
	public

__construct(EntityManagerInterface $em, ClassMetadata $class, Collection<TKey, T>&Selectable<TKey, T> $collection)

Creates a new persistent collection.

Parameters

`$em`	The EntityManager the collection will be associated with.
`$class`	The class descriptor of the entity type of this collection.
`$collection`	The collection elements.


					
	public

setOwner(object $entity, AssociationMapping $assoc): void

INTERNAL: Sets the collection's owning entity together with the AssociationMapping that describes the association…

INTERNAL: Sets the collection's owning entity together with the AssociationMapping that describes the association between the owner and the elements of the collection.


					
	public

getOwner(): object|null

INTERNAL: Gets the collection owner.


					
	public

getTypeClass(): ClassMetadata


					
	private

getUnitOfWork(): UnitOfWork


					
	public

hydrateAdd(mixed $element): void

INTERNAL: Adds an element to a collection during hydration. This will automatically complete bidirectional associations…

INTERNAL: Adds an element to a collection during hydration. This will automatically complete bidirectional associations in the case of a one-to-many association.

Parameters

$element

The element to add.


					
	public

hydrateSet(mixed $key, mixed $element): void

INTERNAL: Sets a keyed element in the collection during hydration.

Parameters

`$key`	The key to set.
`$element`	The element to set.


					
	public

initialize(): void

Initializes the collection by loading its contents from the database if the collection is not yet initialized.

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::initialize()


					
	public

takeSnapshot(): void

INTERNAL: Tells this collection to take a snapshot of its current state.


					
	public

getSnapshot(): array

INTERNAL: Returns the last snapshot of the elements in the collection.


					
	public

getDeleteDiff(): mixed[]

INTERNAL: getDeleteDiff


					
	public

getInsertDiff(): mixed[]

INTERNAL: getInsertDiff


					
	public

getMapping(): array

INTERNAL: Gets the association mapping of the collection.


					
	private

changed(): void

Marks this collection as changed/dirty.


					
	public

isDirty(): bool

Gets a boolean flag indicating whether this collection is dirty which means its state needs to be synchronized with the…

Gets a boolean flag indicating whether this collection is dirty which means its state needs to be synchronized with the database.

Returns

TRUE if the collection is dirty, FALSE otherwise.


					
	public

setDirty(bool $dirty): void

Sets a boolean flag, indicating whether this collection is dirty.

Parameters

$dirty

Whether the collection should be marked dirty or not.


					
	public

setInitialized(bool $bool): void

Sets the initialized flag of the collection, forcing it into that state.


					
	public

remove($key)

{@inheritDoc}

Returns

The removed element or NULL, if the collection did not contain the element.

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::remove()


					
	public

removeElement($element): bool

{@inheritDoc}

Returns

TRUE if this collection contained the specified element, FALSE otherwise.

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::removeElement()


					
	public

containsKey($key): bool

{@inheritDoc}

Returns

TRUE if the collection contains an element with the specified key/index, FALSE otherwise.

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::containsKey()


					
	public

contains<TMaybeContained>($element): bool

{@inheritDoc}

Returns

TRUE if the collection contains the element, FALSE otherwise.

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::contains()


					
	public

get($key)

{@inheritDoc}

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::get()


					
	public

count(): int

{@inheritDoc}

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::count()


					
	public

set($key, $value): void

{@inheritDoc}

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::set()


					
	public

add($value): bool

{@inheritDoc}

Returns

we will require a native return type declaration in 3.0

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::add()


					
	public

offsetExists($offset): bool

{@inheritDoc}

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::offsetExists()


					
	public

offsetGet($offset)

{@inheritDoc}

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::offsetGet()


					
	public

offsetSet($offset, $value): void

{@inheritDoc}

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::offsetSet()


					
	public

offsetUnset($offset): object|null

{@inheritDoc}

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::offsetUnset()


					
	public

isEmpty(): bool

{@inheritDoc}

Returns

TRUE if the collection is empty, FALSE otherwise.

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::isEmpty()


					
	public

clear(): void

{@inheritDoc}

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::clear()


					
	public

__sleep(): string[]

Called by PHP when this collection is serialized. Ensures that only the elements are properly serialized.

Internal note: Tried to implement Serializable first but that did not work well with circular references. This solution seems simpler and works well.


					
	public

slice(int $offset, int|null $length = null): mixed[]

Extracts a slice of $length elements starting at position $offset from the Collection.

If $length is null it returns all elements from $offset to the end of the Collection. Keys have to be preserved by this method. Calling this method will only return the selected slice and NOT change the elements contained in the collection slice is called on.

Parameters

`$offset`	The offset to start from.
`$length`	The maximum number of elements to return, or null for no limit.

Overrides

Doctrine\Common\Collections\AbstractLazyCollection::slice()


					
	public

__clone()

Cleans up internal state of cloned persistent collection.

The following problems have to be prevented:

Added entities are added to old PC
New collection is not dirty, if reused on other entity nothing changes.
Snapshot leads to invalid diffs being generated.
Lazy loading grabs entities from old owner object.
New collection is connected to old owner and leads to duplicate keys.


					
	public

matching(Criteria $criteria): Collection

Selects all elements from a selectable that match the expression and return a new collection containing these elements.

Throws

RuntimeException

Implements

Doctrine\Common\Collections\Selectable::matching()


					
	public

unwrap(): Collection<TKey, T>&Selectable<TKey, T>

Retrieves the wrapped Collection instance.


					
	protected

doInitialize(): void

Do the initialization logic

Implements

Doctrine\Common\Collections\AbstractLazyCollection::doInitialize()


					
	private

restoreNewObjectsInDirtyCollection(object[] $newObjects): void

Methods inherited from Doctrine\Common\Collections\AbstractLazyCollection
`getKeys(), getValues(), toArray(), first(), last(), key(), current(), next(), exists(), findFirst(), filter(), forAll(), map(), reduce(), partition(), indexOf(), getIterator(), isInitialized(),`

Properties
`private`		`$snapshot = []` A snapshot of the collection at the moment it was fetched from the database. This is used to create a diff of the… A snapshot of the collection at the moment it was fetched from the database. This is used to create a diff of the collection at commit time.	#
`private`	`object\|null`	`$owner`	#
`private`		`$association` The association mapping the collection belongs to. This is currently either a OneToManyMapping or a ManyToManyMapping. The association mapping the collection belongs to. This is currently either a OneToManyMapping or a ManyToManyMapping.	#
`private`	`EntityManagerInterface\|null`	`$em`	#
`private`	`string\|null`	`$backRefFieldName`	#
`private`	`ClassMetadata\|null`	`$typeClass`	#
`private`	`bool`	`$isDirty = false`	#

Properties inherited from Doctrine\Common\Collections\AbstractLazyCollection
`$collection, $initialized`

Namespaces

Classes

Interfaces

Exceptions

Class Doctrine\ORM\PersistentCollection

`<TKey is array-key, T>`

Parameters

Parameters

Parameters

Overrides

Returns

Parameters

Returns

Overrides

Returns

Overrides

Returns

Overrides

Returns

Overrides

Overrides

Overrides

Overrides

Returns

Overrides

Overrides

Overrides

Overrides

Overrides

Returns

Overrides

Overrides

Parameters

Overrides

Throws

Implements

Implements