PersistentCollectionTrait::indexOf() - Code Metrics - doctrine/mongodb-odm - Measure and Improve Code Quality continuously with Scrutinizer

PersistentCollectionTrait::indexOf() A
last analyzed 2020-05-19 11:59 UTC

↳ Parent: PersistentCollectionTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php

declare(strict_types=1);

namespace Doctrine\ODM\MongoDB\PersistentCollection;

use Closure;
use Doctrine\Common\Collections\Collection as BaseCollection;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\MongoDBException;
use Doctrine\ODM\MongoDB\UnitOfWork;
use Doctrine\ODM\MongoDB\Utility\CollectionHelper;
use function array_udiff;
use function array_udiff_assoc;
use function array_values;
use function count;
use function get_class;
use function is_object;
use function spl_object_hash;

/**
 * Trait with methods needed to implement PersistentCollectionInterface.
 */
trait PersistentCollectionTrait
{
    /**
     * 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.
     *
     * @var array
     */
    private $snapshot = [];

    /**
     * Collection's owning entity
     *
     * @var object|null
     */
    private $owner;

    /** @var array|null */
    private $mapping;

    /**
     * Whether the collection is dirty and needs to be synchronized with the database
     * when the UnitOfWork that manages its persistent state commits.
     *
     * @var bool
     */
    private $isDirty = false;

    /**
     * Whether the collection has already been initialized.
     *
     * @var bool
     */
    private $initialized = true;

    /**
     * The wrapped Collection instance.
     *
     * @var BaseCollection
     */
    private $coll;

    /**
     * The DocumentManager that manages the persistence of the collection.
     *
     * @var DocumentManager|null
     */
    private $dm;

    /**
     * The UnitOfWork that manages the persistence of the collection.
     *
     * @var UnitOfWork
     */
    private $uow;

    /**
     * The raw mongo data that will be used to initialize this collection.
     *
     * @var array
     */
    private $mongoData = [];

    /**
     * Any hints to account for during reconstitution/lookup of the documents.
     *
     * @var array
     */
    private $hints = [];

    /** {@inheritdoc} */
    public function setDocumentManager(DocumentManager $dm)
    {
        $this->dm  = $dm;
        $this->uow = $dm->getUnitOfWork();
    }

    /** {@inheritdoc} */
    public function setMongoData(array $mongoData)
    {
        $this->mongoData = $mongoData;
    }

    /** {@inheritdoc} */
    public function getMongoData()
    {
        return $this->mongoData;
    }

    /** {@inheritdoc} */
    public function setHints(array $hints)
    {
        $this->hints = $hints;
    }

    /** {@inheritdoc} */
    public function getHints()
    {
        return $this->hints;
    }

    /** {@inheritdoc} */
    public function initialize()
    {
        if ($this->initialized || ! $this->mapping) {
            return;
        }

        $newObjects = [];

        if ($this->isDirty) {
            // Remember any NEW objects added through add()
            $newObjects = $this->coll->toArray();
        }

        $this->initialized = true;

        $this->coll->clear();
        $this->uow->loadCollection($this);
        $this->takeSnapshot();

        $this->mongoData = [];

        // Reattach any NEW objects added through add()
        if (! $newObjects) {
            return;
        }

        foreach ($newObjects as $key => $obj) {
            if (CollectionHelper::isHash($this->mapping['strategy'])) {
                $this->coll->set($key, $obj);
            } else {
                $this->coll->add($obj);
            }
        }

        $this->isDirty = true;
    }

    /**
     * Marks this collection as changed/dirty.
     */
    private function changed()
    {
        if ($this->isDirty) {
            return;
        }

        $this->isDirty = true;

        if (! $this->needsSchedulingForSynchronization() || $this->owner === null) {
            return;
        }

        $this->uow->scheduleForSynchronization($this->owner);
    }

    /** {@inheritdoc} */
    public function isDirty()
    {
        if ($this->isDirty) {
            return true;
        }
        if (! $this->initialized && count($this->coll)) {
            // not initialized collection with added elements
            return true;
        }
        if ($this->initialized) {
            // if initialized let's check with last known snapshot
            return $this->coll->toArray() !== $this->snapshot;
        }

        return false;
    }

    /** {@inheritdoc} */
    public function setDirty($dirty)
    {
        $this->isDirty = $dirty;
    }

    /** {@inheritdoc} */
    public function setOwner(object $document, array $mapping)
    {
        $this->owner   = $document;
        $this->mapping = $mapping;
    }

    /** {@inheritdoc} */
    public function takeSnapshot()
    {
        if ($this->mapping !== null && CollectionHelper::isList($this->mapping['strategy'])) {
            $array = $this->coll->toArray();
            $this->coll->clear();
            foreach ($array as $document) {
                $this->coll->add($document);
            }
        }
        $this->snapshot = $this->coll->toArray();
        $this->isDirty  = false;
    }

    /** {@inheritdoc} */
    public function clearSnapshot()
    {
        $this->snapshot = [];
        $this->isDirty  = $this->coll->count() !== 0;
    }

    /** {@inheritdoc} */
    public function getSnapshot()
    {
        return $this->snapshot;
    }

    /** {@inheritdoc} */
    public function getDeleteDiff()
    {
        return array_udiff_assoc(
            $this->snapshot,
            $this->coll->toArray(),
            static function ($a, $b) {
                return $a === $b ? 0 : 1;
            }
        );
    }

    /** {@inheritdoc} */
    public function getDeletedDocuments()
    {
        $compare = static function ($a, $b) {
            $compareA = is_object($a) ? spl_object_hash($a) : $a;
            $compareb = is_object($b) ? spl_object_hash($b) : $b;

            return $compareA === $compareb ? 0 : ($compareA > $compareb ? 1 : -1);
        };

        return array_values(array_udiff(
            $this->snapshot,
            $this->coll->toArray(),
            $compare
        ));
    }

    /** {@inheritdoc} */
    public function getInsertDiff()
    {
        return array_udiff_assoc(
            $this->coll->toArray(),
            $this->snapshot,
            static function ($a, $b) {
                return $a === $b ? 0 : 1;
            }
        );
    }

    /** {@inheritdoc} */
    public function getInsertedDocuments()
    {
        $compare = static function ($a, $b) {
            $compareA = is_object($a) ? spl_object_hash($a) : $a;
            $compareb = is_object($b) ? spl_object_hash($b) : $b;

            return $compareA === $compareb ? 0 : ($compareA > $compareb ? 1 : -1);
        };

        return array_values(array_udiff(
            $this->coll->toArray(),
            $this->snapshot,
            $compare
        ));
    }

    /** {@inheritdoc} */
    public function getOwner() : ?object
    {
        return $this->owner;
    }

    /** {@inheritdoc} */
    public function getMapping()
    {
        return $this->mapping;
    }

    /** {@inheritdoc} */
    public function getTypeClass()
    {
        if ($this->dm === null) {
            throw new MongoDBException('No DocumentManager is associated with this PersistentCollection, please set one using setDocumentManager method.');
        }

        if (empty($this->mapping)) {
            throw new MongoDBException('No mapping is associated with this PersistentCollection, please set one using setOwner method.');
        }

        if (empty($this->mapping['targetDocument'])) {
            throw new MongoDBException('Specifying targetDocument is required for the ClassMetadata to be obtained.');
        }

        return $this->dm->getClassMetadata($this->mapping['targetDocument']);
    }

    /** {@inheritdoc} */
    public function setInitialized($bool)
    {
        $this->initialized = $bool;
    }

    /** {@inheritdoc} */
    public function isInitialized()
    {
        return $this->initialized;
    }

    /** {@inheritdoc} */
    public function first()
    {
        $this->initialize();

        return $this->coll->first();
    }

    /** {@inheritdoc} */
    public function last()
    {
        $this->initialize();

        return $this->coll->last();
    }

    /**
     * {@inheritdoc}
     */
    public function remove($key)
    {
        return $this->doRemove($key, false);
    }

    /**
     * {@inheritdoc}
     */
    public function removeElement($element)
    {
        $this->initialize();
        $removed = $this->coll->removeElement($element);

        if (! $removed) {
            return $removed;
        }

        $this->changed();

        return $removed;
    }

    /**
     * {@inheritdoc}
     */
    public function containsKey($key)
    {
        $this->initialize();

        return $this->coll->containsKey($key);
    }

    /**
     * {@inheritdoc}
     */
    public function contains($element)
    {
        $this->initialize();

        return $this->coll->contains($element);
    }

    /**
     * {@inheritdoc}
     */
    public function exists(Closure $p)
    {
        $this->initialize();

        return $this->coll->exists($p);
    }

    /**
     * {@inheritdoc}
     */
    public function indexOf($element)
    {
        $this->initialize();

        return $this->coll->indexOf($element);
    }

    /**
     * {@inheritdoc}
     */
    public function get($key)
    {
        $this->initialize();

        return $this->coll->get($key);
    }

    /**
     * {@inheritdoc}
     */
    public function getKeys()
    {
        $this->initialize();

        return $this->coll->getKeys();
    }

    /**
     * {@inheritdoc}
     */
    public function getValues()
    {
        $this->initialize();

        return $this->coll->getValues();
    }

    /**
     * {@inheritdoc}
     */
    public function count()
    {
        // Workaround around not being able to directly count inverse collections anymore
        $this->initialize();

        return $this->coll->count();
    }

    /**
     * {@inheritdoc}
     */
    public function set($key, $value)
    {
        return $this->doSet($key, $value, false);
    }

    /**
     * {@inheritdoc}
     */
    public function add($value)
    {
        return $this->doAdd($value, false);
    }

    /**
     * {@inheritdoc}
     */
    public function isEmpty()
    {
        return $this->initialized ? $this->coll->isEmpty() : $this->count() === 0;
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator()
    {
        $this->initialize();

        return $this->coll->getIterator();
    }

    /**
     * {@inheritdoc}
     */
    public function map(Closure $func)
    {
        $this->initialize();

        return $this->coll->map($func);
    }

    /**
     * {@inheritdoc}
     */
    public function filter(Closure $p)
    {
        $this->initialize();

        return $this->coll->filter($p);
    }

    /**
     * {@inheritdoc}
     */
    public function forAll(Closure $p)
    {
        $this->initialize();

        return $this->coll->forAll($p);
    }

    /**
     * {@inheritdoc}
     */
    public function partition(Closure $p)
    {
        $this->initialize();

        return $this->coll->partition($p);
    }

    /**
     * {@inheritdoc}
     */
    public function toArray()
    {
        $this->initialize();

        return $this->coll->toArray();
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        if ($this->initialized && $this->isEmpty()) {
            return;
        }

        if ($this->isOrphanRemovalEnabled()) {
            $this->initialize();
            foreach ($this->coll as $element) {
                $this->uow->scheduleOrphanRemoval($element);
            }
        }

        $this->mongoData = [];
        $this->coll->clear();

        // Nothing to do for inverse-side collections
        if (! $this->mapping['isOwningSide']) {
            return;
        }

        // Nothing to do if the collection was initialized but contained no data
        if ($this->initialized && empty($this->snapshot)) {
            return;
        }

        $this->changed();
        $this->uow->scheduleCollectionDeletion($this);
        $this->takeSnapshot();
    }

    /**
     * {@inheritdoc}
     */
    public function slice($offset, $length = null)
    {
        $this->initialize();

        return $this->coll->slice($offset, $length);
    }

    /**
     * Called by PHP when this collection is serialized. Ensures that the
     * internal state of the collection can be reproduced after serialization
     */
    public function __sleep()
    {
        return ['coll', 'initialized', 'mongoData', 'snapshot', 'isDirty', 'hints'];
    }

    /* ArrayAccess implementation */

    /**
     * @see containsKey()
     */
    public function offsetExists($offset)
    {
        $this->initialize();

        return $this->coll->offsetExists($offset);
    }

    /**
     * @see get()
     */
    public function offsetGet($offset)
    {
        $this->initialize();

        return $this->coll->offsetGet($offset);
    }

    /**
     * @see add()
     * @see set()
     */
    public function offsetSet($offset, $value)
    {
        if (! isset($offset)) {
            return $this->doAdd($value, true);
        }

        $this->doSet($offset, $value, true);
    }

    /**
     * @see remove()
     */
    public function offsetUnset($offset)
    {
        $this->doRemove($offset, true);
    }

    public function key()
    {
        return $this->coll->key();
    }

    /**
     * Gets the element of the collection at the current iterator position.
     */
    public function current()
    {
        return $this->coll->current();
    }

    /**
     * Moves the internal iterator position to the next element.
     */
    public function next()
    {
        return $this->coll->next();
    }

    /**
     * {@inheritdoc}
     */
    public function unwrap()
    {
        return $this->coll;
    }

    /**
     * Cleanup internal state of cloned persistent collection.
     *
     * The following problems have to be prevented:
     * 1. Added documents are added to old PersistentCollection
     * 2. New collection is not dirty, if reused on other document nothing
     * changes.
     * 3. Snapshot leads to invalid diffs being generated.
     * 4. Lazy loading grabs entities from old owner object.
     * 5. New collection is connected to old owner and leads to duplicate keys.
     */
    public function __clone()
    {
        if (is_object($this->coll)) {
            $this->coll = clone $this->coll;
        }

        $this->initialize();

        $this->owner    = null;
        $this->snapshot = [];

        $this->changed();
    }

    /**
     * Actual logic for adding an element to the collection.
     *
     * @param mixed $value
     * @param bool  $arrayAccess
     *
     * @return bool
     */
    private function doAdd($value, $arrayAccess)
    {
        /* Initialize the collection before calling add() so this append operation
         * uses the appropriate key. Otherwise, we risk overwriting original data
         * when $newObjects are re-added in a later call to initialize().
         */
        if (isset($this->mapping['strategy']) && CollectionHelper::isHash($this->mapping['strategy'])) {
            $this->initialize();
        }
        $arrayAccess ? $this->coll->offsetSet(null, $value) : $this->coll->add($value);
        $this->changed();

        if ($this->uow !== null && $this->isOrphanRemovalEnabled() && $value !== null) {
            $this->uow->unscheduleOrphanRemoval($value);
        }

        return true;
    }

    /**
     * Actual logic for removing element by its key.
     *
     * @param mixed $offset
     * @param bool  $arrayAccess
     *
     * @return bool
     */
    private function doRemove($offset, $arrayAccess)
    {
        $this->initialize();
        if ($arrayAccess) {
            $this->coll->offsetUnset($offset);
            $removed = true;
        } else {
            $removed = $this->coll->remove($offset);
        }

        if (! $removed && ! $arrayAccess) {
            return $removed;
        }

        $this->changed();

        return $removed;
    }

    /**
     * Actual logic for setting an element in the collection.
     *
     * @param mixed $offset
     * @param mixed $value
     * @param bool  $arrayAccess
     */
    private function doSet($offset, $value, $arrayAccess)
    {
        $arrayAccess ? $this->coll->offsetSet($offset, $value) : $this->coll->set($offset, $value);

        // Handle orphanRemoval
        if ($this->uow !== null && $this->isOrphanRemovalEnabled() && $value !== null) {
            $this->uow->unscheduleOrphanRemoval($value);
        }

        $this->changed();
    }

    /**
     * Returns whether or not this collection has orphan removal enabled.
     *
     * Embedded documents are automatically considered as "orphan removal enabled" because they might have references
     * that require to trigger cascade remove operations.
     *
     * @return bool
     */
    private function isOrphanRemovalEnabled()
    {
        if ($this->mapping === null) {
            return false;
        }

        if (isset($this->mapping['embedded'])) {
            return true;
        }

        return isset($this->mapping['reference']) && $this->mapping['isOwningSide'] && $this->mapping['orphanRemoval'];
    }

    /**
     * Checks whether collection owner needs to be scheduled for dirty change in case the collection is modified.
     *
     * @return bool
     */
    private function needsSchedulingForSynchronization()
    {
        return $this->owner && $this->dm && ! empty($this->mapping['isOwningSide'])
            && $this->dm->getClassMetadata(get_class($this->owner))->isChangeTrackingNotify();
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Doctrine\ODM\MongoDB\PersistentCollection;
6
7		use Closure;
8		use Doctrine\Common\Collections\Collection as BaseCollection;
9		use Doctrine\ODM\MongoDB\DocumentManager;
10		use Doctrine\ODM\MongoDB\MongoDBException;
11		use Doctrine\ODM\MongoDB\UnitOfWork;
12		use Doctrine\ODM\MongoDB\Utility\CollectionHelper;
13		use function array_udiff;
14		use function array_udiff_assoc;
15		use function array_values;
16		use function count;
17		use function get_class;
18		use function is_object;
19		use function spl_object_hash;
20
21		/**
22		* Trait with methods needed to implement PersistentCollectionInterface.
23		*/
24		trait PersistentCollectionTrait
25		{
26		/**
27		* A snapshot of the collection at the moment it was fetched from the database.
28		* This is used to create a diff of the collection at commit time.
29		*
30		* @var array
31		*/
32		private $snapshot = [];
33
34		/**
35		* Collection's owning entity
36		*
37		* @var object\|null
38		*/
39		private $owner;
40
41		/** @var array\|null */
42		private $mapping;
43
44		/**
45		* Whether the collection is dirty and needs to be synchronized with the database
46		* when the UnitOfWork that manages its persistent state commits.
47		*
48		* @var bool
49		*/
50		private $isDirty = false;
51
52		/**
53		* Whether the collection has already been initialized.
54		*
55		* @var bool
56		*/
57		private $initialized = true;
58
59		/**
60		* The wrapped Collection instance.
61		*
62		* @var BaseCollection
63		*/
64		private $coll;
65
66		/**
67		* The DocumentManager that manages the persistence of the collection.
68		*
69		* @var DocumentManager\|null
70		*/
71		private $dm;
72
73		/**
74		* The UnitOfWork that manages the persistence of the collection.
75		*
76		* @var UnitOfWork
77		*/
78		private $uow;
79
80		/**
81		* The raw mongo data that will be used to initialize this collection.
82		*
83		* @var array
84		*/
85		private $mongoData = [];
86
87		/**
88		* Any hints to account for during reconstitution/lookup of the documents.
89		*
90		* @var array
91		*/
92		private $hints = [];
93
94		/** {@inheritdoc} */
95	4	public function setDocumentManager(DocumentManager $dm)
96		{
97	4	$this->dm = $dm;
98	4	$this->uow = $dm->getUnitOfWork();
99	4	}
100
101		/** {@inheritdoc} */
102	169	public function setMongoData(array $mongoData)
103		{
104	169	$this->mongoData = $mongoData;
105	169	}
106
107		/** {@inheritdoc} */
108	167	public function getMongoData()
109		{
110	167	return $this->mongoData;
111		}
112
113		/** {@inheritdoc} */
114	254	public function setHints(array $hints)
115		{
116	254	$this->hints = $hints;
117	254	}
118
119		/** {@inheritdoc} */
120	166	public function getHints()
121		{
122	166	return $this->hints;
123		}
124
125		/** {@inheritdoc} */
126	413	public function initialize()
127		{
128	413	if ($this->initialized \|\| ! $this->mapping) {
129	403	return;
130		}
131
132	181	$newObjects = [];
133
134	181	if ($this->isDirty) {
135		// Remember any NEW objects added through add()
136	17	$newObjects = $this->coll->toArray();
137		}
138
139	181	$this->initialized = true;
140
141	181	$this->coll->clear();
142	181	$this->uow->loadCollection($this);
143	179	$this->takeSnapshot();
144
145	179	$this->mongoData = [];
146
147		// Reattach any NEW objects added through add()
148	179	if (! $newObjects) {
149	175	return;
150		}
151
152	17	foreach ($newObjects as $key => $obj) {
153	17	if (CollectionHelper::isHash($this->mapping['strategy'])) {
154		$this->coll->set($key, $obj);
155		} else {
156	17	$this->coll->add($obj);
157		}
158		}
159
160	17	$this->isDirty = true;
161	17	}
162
163		/**
164		* Marks this collection as changed/dirty.
165		*/
166	211	private function changed()
167		{
168	211	if ($this->isDirty) {
169	132	return;
170		}
171
172	211	$this->isDirty = true;
173
174	211	if (! $this->needsSchedulingForSynchronization() \|\| $this->owner === null) {
175	210	return;
176		}
177
178	1	$this->uow->scheduleForSynchronization($this->owner);
179	1	}
180
181		/** {@inheritdoc} */
182	425	public function isDirty()
183		{
184	425	if ($this->isDirty) {
185	278	return true;
186		}
187	375	if (! $this->initialized && count($this->coll)) {
188		// not initialized collection with added elements
189		return true;
190		}
191	375	if ($this->initialized) {
192		// if initialized let's check with last known snapshot
193	369	return $this->coll->toArray() !== $this->snapshot;
194		}
195
196	95	return false;
197		}
198
199		/** {@inheritdoc} */
200	413	public function setDirty($dirty)
201		{
202	413	$this->isDirty = $dirty;
203	413	}
204
205		/** {@inheritdoc} */
206	441	public function setOwner(object $document, array $mapping)
207		{
208	441	$this->owner = $document;
209	441	$this->mapping = $mapping;
210	441	}
211
212		/** {@inheritdoc} */
213	299	public function takeSnapshot()
214		{
215	299	if ($this->mapping !== null && CollectionHelper::isList($this->mapping['strategy'])) {
216	274	$array = $this->coll->toArray();
217	274	$this->coll->clear();
218	274	foreach ($array as $document) {
219	249	$this->coll->add($document);
220		}
221		}
222	299	$this->snapshot = $this->coll->toArray();
223	299	$this->isDirty = false;
224	299	}
225
226		/** {@inheritdoc} */
227	29	public function clearSnapshot()
228		{
229	29	$this->snapshot = [];
230	29	$this->isDirty = $this->coll->count() !== 0;
231	29	}
232
233		/** {@inheritdoc} */
234	1	public function getSnapshot()
235		{
236	1	return $this->snapshot;
237		}
238
239		/** {@inheritdoc} */
240	96	public function getDeleteDiff()
241		{
242	96	return array_udiff_assoc(
243	96	$this->snapshot,
244	96	$this->coll->toArray(),
245		static function ($a, $b) {
246	48	return $a === $b ? 0 : 1;
247	96	}
248		);
249		}
250
251		/** {@inheritdoc} */
252	157	public function getDeletedDocuments()
253		{
254		$compare = static function ($a, $b) {
255	109	$compareA = is_object($a) ? spl_object_hash($a) : $a;
256	109	$compareb = is_object($b) ? spl_object_hash($b) : $b;
257
258	109	return $compareA === $compareb ? 0 : ($compareA > $compareb ? 1 : -1);
259	157	};
260
261	157	return array_values(array_udiff(
262	157	$this->snapshot,
263	157	$this->coll->toArray(),
264	157	$compare
265		));
266		}
267
268		/** {@inheritdoc} */
269	96	public function getInsertDiff()
270		{
271	96	return array_udiff_assoc(
272	96	$this->coll->toArray(),
273	96	$this->snapshot,
274		static function ($a, $b) {
275	48	return $a === $b ? 0 : 1;
276	96	}
277		);
278		}
279
280		/** {@inheritdoc} */
281	4	public function getInsertedDocuments()
282		{
283		$compare = static function ($a, $b) {
284	4	$compareA = is_object($a) ? spl_object_hash($a) : $a;
285	4	$compareb = is_object($b) ? spl_object_hash($b) : $b;
286
287	4	return $compareA === $compareb ? 0 : ($compareA > $compareb ? 1 : -1);
288	4	};
289
290	4	return array_values(array_udiff(
291	4	$this->coll->toArray(),
292	4	$this->snapshot,
293	4	$compare
294		));
295		}
296
297		/** {@inheritdoc} */
298	425	public function getOwner() : ?object
299		{
300	425	return $this->owner;
301		}
302
303		/** {@inheritdoc} */
304	295	public function getMapping()
305		{
306	295	return $this->mapping;
307		}
308
309		/** {@inheritdoc} */
310	5	public function getTypeClass()
311		{
312	5	if ($this->dm === null) {
313	1	throw new MongoDBException('No DocumentManager is associated with this PersistentCollection, please set one using setDocumentManager method.');
314		}
315
316	4	if (empty($this->mapping)) {
317	1	throw new MongoDBException('No mapping is associated with this PersistentCollection, please set one using setOwner method.');
318		}
319
320	3	if (empty($this->mapping['targetDocument'])) {
321	1	throw new MongoDBException('Specifying targetDocument is required for the ClassMetadata to be obtained.');
322		}
323
324	2	return $this->dm->getClassMetadata($this->mapping['targetDocument']);
325		}
326
327		/** {@inheritdoc} */
328	257	public function setInitialized($bool)
329		{
330	257	$this->initialized = $bool;
331	257	}
332
333		/** {@inheritdoc} */
334	19	public function isInitialized()
335		{
336	19	return $this->initialized;
337		}
338
339		/** {@inheritdoc} */
340	16	public function first()
341		{
342	16	$this->initialize();
343
344	16	return $this->coll->first();
345		}
346
347		/** {@inheritdoc} */
348	2	public function last()
349		{
350	2	$this->initialize();
351
352	2	return $this->coll->last();
353		}
354
355		/**
356		* {@inheritdoc}
357		*/
358	6	public function remove($key)
359		{
360	6	return $this->doRemove($key, false);
361		}
362
363		/**
364		* {@inheritdoc}
365		*/
366	16	public function removeElement($element)
367		{
368	16	$this->initialize();
369	16	$removed = $this->coll->removeElement($element);
370
371	16	if (! $removed) {
372		return $removed;
373		}
374
375	16	$this->changed();
376
377	16	return $removed;
378		}
379
380		/**
381		* {@inheritdoc}
382		*/
383		public function containsKey($key)
384		{
385		$this->initialize();
386
387		return $this->coll->containsKey($key);
388		}
389
390		/**
391		* {@inheritdoc}
392		*/
393	3	public function contains($element)
394		{
395	3	$this->initialize();
396
397	3	return $this->coll->contains($element);
398		}
399
400		/**
401		* {@inheritdoc}
402		*/
403		public function exists(Closure $p)
404		{
405		$this->initialize();
406
407		return $this->coll->exists($p);
408		}
409
410		/**
411		* {@inheritdoc}
412		*/
413	2	public function indexOf($element)
414		{
415	2	$this->initialize();
416
417	2	return $this->coll->indexOf($element);
418		}
419
420		/**
421		* {@inheritdoc}
422		*/
423	20	public function get($key)
424		{
425	20	$this->initialize();
426
427	20	return $this->coll->get($key);
428		}
429
430		/**
431		* {@inheritdoc}
432		*/
433		public function getKeys()
434		{
435		$this->initialize();
436
437		return $this->coll->getKeys();
438		}
439
440		/**
441		* {@inheritdoc}
442		*/
443		public function getValues()
444		{
445		$this->initialize();
446
447		return $this->coll->getValues();
448		}
449
450		/**
451		* {@inheritdoc}
452		*/
453	117	public function count()
454		{
455		// Workaround around not being able to directly count inverse collections anymore
456	117	$this->initialize();
457
458	117	return $this->coll->count();
459		}
460
461		/**
462		* {@inheritdoc}
463		*/
464	35	public function set($key, $value)
465		{
466	35	return $this->doSet($key, $value, false);
467		}
468
469		/**
470		* {@inheritdoc}
471		*/
472	170	public function add($value)
473		{
474	170	return $this->doAdd($value, false);
475		}
476
477		/**
478		* {@inheritdoc}
479		*/
480	394	public function isEmpty()
481		{
482	394	return $this->initialized ? $this->coll->isEmpty() : $this->count() === 0;
483		}
484
485		/**
486		* {@inheritdoc}
487		*/
488	335	public function getIterator()
489		{
490	335	$this->initialize();
491
492	335	return $this->coll->getIterator();
493		}
494
495		/**
496		* {@inheritdoc}
497		*/
498	234	public function map(Closure $func)
499		{
500	234	$this->initialize();
501
502	234	return $this->coll->map($func);
503		}
504
505		/**
506		* {@inheritdoc}
507		*/
508		public function filter(Closure $p)
509		{
510		$this->initialize();
511
512		return $this->coll->filter($p);
513		}
514
515		/**
516		* {@inheritdoc}
517		*/
518		public function forAll(Closure $p)
519		{
520		$this->initialize();
521
522		return $this->coll->forAll($p);
523		}
524
525		/**
526		* {@inheritdoc}
527		*/
528		public function partition(Closure $p)
529		{
530		$this->initialize();
531
532		return $this->coll->partition($p);
533		}
534
535		/**
536		* {@inheritdoc}
537		*/
538	23	public function toArray()
539		{
540	23	$this->initialize();
541
542	23	return $this->coll->toArray();
543		}
544
545		/**
546		* {@inheritdoc}
547		*/
548	33	public function clear()
549		{
550	33	if ($this->initialized && $this->isEmpty()) {
551		return;
552		}
553
554	33	if ($this->isOrphanRemovalEnabled()) {
555	32	$this->initialize();
556	32	foreach ($this->coll as $element) {
557	32	$this->uow->scheduleOrphanRemoval($element);
558		}
559		}
560
561	33	$this->mongoData = [];
562	33	$this->coll->clear();
563
564		// Nothing to do for inverse-side collections
565	33	if (! $this->mapping['isOwningSide']) {
566		return;
567		}
568
569		// Nothing to do if the collection was initialized but contained no data
570	33	if ($this->initialized && empty($this->snapshot)) {
571	2	return;
572		}
573
574	31	$this->changed();
575	31	$this->uow->scheduleCollectionDeletion($this);
576	31	$this->takeSnapshot();
577	31	}
578
579		/**
580		* {@inheritdoc}
581		*/
582	1	public function slice($offset, $length = null)
583		{
584	1	$this->initialize();
585
586	1	return $this->coll->slice($offset, $length);
587		}
588
589		/**
590		* Called by PHP when this collection is serialized. Ensures that the
591		* internal state of the collection can be reproduced after serialization
592		*/
593	6	public function __sleep()
594		{
595	6	return ['coll', 'initialized', 'mongoData', 'snapshot', 'isDirty', 'hints'];
596		}
597
598		/* ArrayAccess implementation */
599
600		/**
601		* @see containsKey()
602		*/
603	2	public function offsetExists($offset)
604		{
605	2	$this->initialize();
606
607	2	return $this->coll->offsetExists($offset);
608		}
609
610		/**
611		* @see get()
612		*/
613	78	public function offsetGet($offset)
614		{
615	78	$this->initialize();
616
617	78	return $this->coll->offsetGet($offset);
618		}
619
620		/**
621		* @see add()
622		* @see set()
623		*/
624	42	public function offsetSet($offset, $value)
625		{
626	42	if (! isset($offset)) {
627	41	return $this->doAdd($value, true);
628		}
629
630	3	$this->doSet($offset, $value, true);
631	3	}
632
633		/**
634		* @see remove()
635		*/
636	19	public function offsetUnset($offset)
637		{
638	19	$this->doRemove($offset, true);
639	19	}
640
641		public function key()
642		{
643		return $this->coll->key();
644		}
645
646		/**
647		* Gets the element of the collection at the current iterator position.
648		*/
649	1	public function current()
650		{
651	1	return $this->coll->current();
652		}
653
654		/**
655		* Moves the internal iterator position to the next element.
656		*/
657		public function next()
658		{
659		return $this->coll->next();
660		}
661
662		/**
663		* {@inheritdoc}
664		*/
665	424	public function unwrap()
666		{
667	424	return $this->coll;
668		}
669
670		/**
671		* Cleanup internal state of cloned persistent collection.
672		*
673		* The following problems have to be prevented:
674		* 1. Added documents are added to old PersistentCollection
675		* 2. New collection is not dirty, if reused on other document nothing
676		* changes.
677		* 3. Snapshot leads to invalid diffs being generated.
678		* 4. Lazy loading grabs entities from old owner object.
679		* 5. New collection is connected to old owner and leads to duplicate keys.
680		*/
681	8	public function __clone()
682		{
683	8	if (is_object($this->coll)) {
684	8	$this->coll = clone $this->coll;
685		}
686
687	8	$this->initialize();
688
689	8	$this->owner = null;
690	8	$this->snapshot = [];
691
692	8	$this->changed();
693	8	}
694
695		/**
696		* Actual logic for adding an element to the collection.
697		*
698		* @param mixed $value
699		* @param bool $arrayAccess
700		*
701		* @return bool
702		*/
703	186	private function doAdd($value, $arrayAccess)
704		{
705		/* Initialize the collection before calling add() so this append operation
706		* uses the appropriate key. Otherwise, we risk overwriting original data
707		* when $newObjects are re-added in a later call to initialize().
708		*/
709	186	if (isset($this->mapping['strategy']) && CollectionHelper::isHash($this->mapping['strategy'])) {
710	15	$this->initialize();
711		}
712	186	$arrayAccess ? $this->coll->offsetSet(null, $value) : $this->coll->add($value);
713	186	$this->changed();
714
715	186	if ($this->uow !== null && $this->isOrphanRemovalEnabled() && $value !== null) {
716	108	$this->uow->unscheduleOrphanRemoval($value);
717		}
718
719	186	return true;
720		}
721
722		/**
723		* Actual logic for removing element by its key.
724		*
725		* @param mixed $offset
726		* @param bool $arrayAccess
727		*
728		* @return bool
729		*/
730	25	private function doRemove($offset, $arrayAccess)
731		{
732	25	$this->initialize();
733	25	if ($arrayAccess) {
734	19	$this->coll->offsetUnset($offset);
735	19	$removed = true;
736		} else {
737	6	$removed = $this->coll->remove($offset);
738		}
739
740	25	if (! $removed && ! $arrayAccess) {
741		return $removed;
742		}
743
744	25	$this->changed();
745
746	25	return $removed;
747		}
748
749		/**
750		* Actual logic for setting an element in the collection.
751		*
752		* @param mixed $offset
753		* @param mixed $value
754		* @param bool $arrayAccess
755		*/
756	36	private function doSet($offset, $value, $arrayAccess)
757		{
758	36	$arrayAccess ? $this->coll->offsetSet($offset, $value) : $this->coll->set($offset, $value);
759
760		// Handle orphanRemoval
761	36	if ($this->uow !== null && $this->isOrphanRemovalEnabled() && $value !== null) {
762	34	$this->uow->unscheduleOrphanRemoval($value);
763		}
764
765	36	$this->changed();
766	36	}
767
768		/**
769		* Returns whether or not this collection has orphan removal enabled.
770		*
771		* Embedded documents are automatically considered as "orphan removal enabled" because they might have references
772		* that require to trigger cascade remove operations.
773		*
774		* @return bool
775		*/
776	204	private function isOrphanRemovalEnabled()
777		{
778	204	if ($this->mapping === null) {
779	12	return false;
780		}
781
782	192	if (isset($this->mapping['embedded'])) {
783	117	return true;
784		}
785
786	85	return isset($this->mapping['reference']) && $this->mapping['isOwningSide'] && $this->mapping['orphanRemoval'];
787		}
788
789		/**
790		* Checks whether collection owner needs to be scheduled for dirty change in case the collection is modified.
791		*
792		* @return bool
793		*/
794	211	private function needsSchedulingForSynchronization()
795		{
796	211	return $this->owner && $this->dm && ! empty($this->mapping['isOwningSide'])
797	211	&& $this->dm->getClassMetadata(get_class($this->owner))->isChangeTrackingNotify();
798		}
799		}
800

doctrine / mongodb-odm

PersistentCollectionTrait::indexOf() A last analyzed 2020-05-19 11:59 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

PersistentCollectionTrait::indexOf() A
last analyzed 2020-05-19 11:59 UTC