These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
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 | */ |
||
19 | |||
20 | namespace Doctrine\ORM; |
||
21 | |||
22 | use Doctrine\Common\Annotations\AnnotationReader; |
||
23 | use Doctrine\Common\Annotations\AnnotationRegistry; |
||
24 | use Doctrine\Common\Annotations\CachedReader; |
||
25 | use Doctrine\Common\Annotations\SimpleAnnotationReader; |
||
26 | use Doctrine\Common\Cache\ArrayCache; |
||
27 | use Doctrine\Common\Cache\Cache as CacheDriver; |
||
28 | use Doctrine\Common\Persistence\Mapping\Driver\MappingDriver; |
||
29 | use Doctrine\Common\Persistence\ObjectRepository; |
||
30 | use Doctrine\Common\Proxy\AbstractProxyFactory; |
||
31 | use Doctrine\ORM\Cache\CacheConfiguration; |
||
32 | use Doctrine\ORM\Mapping\ClassMetadataFactory; |
||
33 | use Doctrine\ORM\Mapping\DefaultEntityListenerResolver; |
||
34 | use Doctrine\ORM\Mapping\DefaultNamingStrategy; |
||
35 | use Doctrine\ORM\Mapping\DefaultQuoteStrategy; |
||
36 | use Doctrine\ORM\Mapping\Driver\AnnotationDriver; |
||
37 | use Doctrine\ORM\Mapping\EntityListenerResolver; |
||
38 | use Doctrine\ORM\Mapping\NamingStrategy; |
||
39 | use Doctrine\ORM\Mapping\QuoteStrategy; |
||
40 | use Doctrine\ORM\Repository\DefaultRepositoryFactory; |
||
41 | use Doctrine\ORM\Repository\RepositoryFactory; |
||
42 | |||
43 | /** |
||
44 | * Configuration container for all configuration options of Doctrine. |
||
45 | * It combines all configuration options from DBAL & ORM. |
||
46 | * |
||
47 | * Internal note: When adding a new configuration option just write a getter/setter pair. |
||
48 | * |
||
49 | * @since 2.0 |
||
50 | * @author Benjamin Eberlei <[email protected]> |
||
51 | * @author Guilherme Blanco <[email protected]> |
||
52 | * @author Jonathan Wage <[email protected]> |
||
53 | * @author Roman Borschel <[email protected]> |
||
54 | */ |
||
55 | class Configuration extends \Doctrine\DBAL\Configuration |
||
56 | { |
||
57 | /** |
||
58 | * Sets the directory where Doctrine generates any necessary proxy class files. |
||
59 | * |
||
60 | * @param string $dir |
||
61 | * |
||
62 | * @return void |
||
63 | */ |
||
64 | 2398 | public function setProxyDir($dir) |
|
65 | { |
||
66 | 2398 | $this->_attributes['proxyDir'] = $dir; |
|
67 | 2398 | } |
|
68 | |||
69 | /** |
||
70 | * Gets the directory where Doctrine generates any necessary proxy class files. |
||
71 | * |
||
72 | * @return string|null |
||
73 | */ |
||
74 | 2394 | public function getProxyDir() |
|
75 | { |
||
76 | 2394 | return isset($this->_attributes['proxyDir']) |
|
77 | 2394 | ? $this->_attributes['proxyDir'] |
|
78 | 2394 | : null; |
|
79 | } |
||
80 | |||
81 | /** |
||
82 | * Gets the strategy for automatically generating proxy classes. |
||
83 | * |
||
84 | * @return int Possible values are constants of Doctrine\Common\Proxy\AbstractProxyFactory. |
||
85 | */ |
||
86 | 2396 | public function getAutoGenerateProxyClasses() |
|
87 | { |
||
88 | 2396 | return isset($this->_attributes['autoGenerateProxyClasses']) |
|
89 | 5 | ? $this->_attributes['autoGenerateProxyClasses'] |
|
90 | 2396 | : AbstractProxyFactory::AUTOGENERATE_ALWAYS; |
|
91 | } |
||
92 | |||
93 | /** |
||
94 | * Sets the strategy for automatically generating proxy classes. |
||
95 | * |
||
96 | * @param boolean|int $autoGenerate Possible values are constants of Doctrine\Common\Proxy\AbstractProxyFactory. |
||
97 | * True is converted to AUTOGENERATE_ALWAYS, false to AUTOGENERATE_NEVER. |
||
98 | * |
||
99 | * @return void |
||
100 | */ |
||
101 | 15 | public function setAutoGenerateProxyClasses($autoGenerate) |
|
102 | { |
||
103 | 15 | $this->_attributes['autoGenerateProxyClasses'] = (int) $autoGenerate; |
|
104 | 15 | } |
|
105 | |||
106 | /** |
||
107 | * Gets the namespace where proxy classes reside. |
||
108 | * |
||
109 | * @return string|null |
||
110 | */ |
||
111 | 2393 | public function getProxyNamespace() |
|
112 | { |
||
113 | 2393 | return isset($this->_attributes['proxyNamespace']) |
|
114 | 2393 | ? $this->_attributes['proxyNamespace'] |
|
115 | 2393 | : null; |
|
116 | } |
||
117 | |||
118 | /** |
||
119 | * Sets the namespace where proxy classes reside. |
||
120 | * |
||
121 | * @param string $ns |
||
122 | * |
||
123 | * @return void |
||
124 | */ |
||
125 | 2398 | public function setProxyNamespace($ns) |
|
126 | { |
||
127 | 2398 | $this->_attributes['proxyNamespace'] = $ns; |
|
128 | 2398 | } |
|
129 | |||
130 | /** |
||
131 | * Sets the cache driver implementation that is used for metadata caching. |
||
132 | * |
||
133 | * @param MappingDriver $driverImpl |
||
134 | * |
||
135 | * @return void |
||
136 | * |
||
137 | * @todo Force parameter to be a Closure to ensure lazy evaluation |
||
138 | * (as soon as a metadata cache is in effect, the driver never needs to initialize). |
||
139 | */ |
||
140 | 2397 | public function setMetadataDriverImpl(MappingDriver $driverImpl) |
|
141 | { |
||
142 | 2397 | $this->_attributes['metadataDriverImpl'] = $driverImpl; |
|
143 | 2397 | } |
|
144 | |||
145 | /** |
||
146 | * Adds a new default annotation driver with a correctly configured annotation reader. If $useSimpleAnnotationReader |
||
147 | * is true, the notation `@Entity` will work, otherwise, the notation `@ORM\Entity` will be supported. |
||
148 | * |
||
149 | * @param array $paths |
||
150 | * @param bool $useSimpleAnnotationReader |
||
151 | * |
||
152 | * @return AnnotationDriver |
||
153 | */ |
||
154 | 2373 | public function newDefaultAnnotationDriver($paths = [], $useSimpleAnnotationReader = true) |
|
155 | { |
||
156 | 2373 | AnnotationRegistry::registerFile(__DIR__ . '/Mapping/Driver/DoctrineAnnotations.php'); |
|
0 ignored issues
–
show
|
|||
157 | |||
158 | 2373 | if ($useSimpleAnnotationReader) { |
|
159 | // Register the ORM Annotations in the AnnotationRegistry |
||
160 | 2373 | $reader = new SimpleAnnotationReader(); |
|
161 | 2373 | $reader->addNamespace('Doctrine\ORM\Mapping'); |
|
162 | 2373 | $cachedReader = new CachedReader($reader, new ArrayCache()); |
|
163 | |||
164 | 2373 | return new AnnotationDriver($cachedReader, (array) $paths); |
|
165 | } |
||
166 | |||
167 | 1 | return new AnnotationDriver( |
|
168 | 1 | new CachedReader(new AnnotationReader(), new ArrayCache()), |
|
169 | 1 | (array) $paths |
|
170 | ); |
||
171 | } |
||
172 | |||
173 | /** |
||
174 | * Adds a namespace under a certain alias. |
||
175 | * |
||
176 | * @param string $alias |
||
177 | * @param string $namespace |
||
178 | * |
||
179 | * @return void |
||
180 | */ |
||
181 | 8 | public function addEntityNamespace($alias, $namespace) |
|
182 | { |
||
183 | 8 | $this->_attributes['entityNamespaces'][$alias] = $namespace; |
|
184 | 8 | } |
|
185 | |||
186 | /** |
||
187 | * Resolves a registered namespace alias to the full namespace. |
||
188 | * |
||
189 | * @param string $entityNamespaceAlias |
||
190 | * |
||
191 | * @return string |
||
192 | * |
||
193 | * @throws ORMException |
||
194 | */ |
||
195 | 13 | public function getEntityNamespace($entityNamespaceAlias) |
|
196 | { |
||
197 | 13 | if ( ! isset($this->_attributes['entityNamespaces'][$entityNamespaceAlias])) { |
|
198 | 1 | throw ORMException::unknownEntityNamespace($entityNamespaceAlias); |
|
199 | } |
||
200 | |||
201 | 13 | return trim($this->_attributes['entityNamespaces'][$entityNamespaceAlias], '\\'); |
|
202 | } |
||
203 | |||
204 | /** |
||
205 | * Sets the entity alias map. |
||
206 | * |
||
207 | * @param array $entityNamespaces |
||
208 | * |
||
209 | * @return void |
||
210 | */ |
||
211 | 97 | public function setEntityNamespaces(array $entityNamespaces) |
|
212 | { |
||
213 | 97 | $this->_attributes['entityNamespaces'] = $entityNamespaces; |
|
214 | 97 | } |
|
215 | |||
216 | /** |
||
217 | * Retrieves the list of registered entity namespace aliases. |
||
218 | * |
||
219 | * @return array |
||
220 | */ |
||
221 | 1 | public function getEntityNamespaces() |
|
222 | { |
||
223 | 1 | return $this->_attributes['entityNamespaces']; |
|
224 | } |
||
225 | |||
226 | /** |
||
227 | * Gets the cache driver implementation that is used for the mapping metadata. |
||
228 | * |
||
229 | * @return MappingDriver|null |
||
230 | * |
||
231 | * @throws ORMException |
||
232 | */ |
||
233 | 1525 | public function getMetadataDriverImpl() |
|
234 | { |
||
235 | 1525 | return isset($this->_attributes['metadataDriverImpl']) |
|
236 | 1525 | ? $this->_attributes['metadataDriverImpl'] |
|
237 | 1525 | : null; |
|
238 | } |
||
239 | |||
240 | /** |
||
241 | * Gets the cache driver implementation that is used for the query cache (SQL cache). |
||
242 | * |
||
243 | * @return \Doctrine\Common\Cache\Cache|null |
||
244 | */ |
||
245 | 582 | public function getQueryCacheImpl() |
|
246 | { |
||
247 | 582 | return isset($this->_attributes['queryCacheImpl']) |
|
248 | 581 | ? $this->_attributes['queryCacheImpl'] |
|
249 | 582 | : null; |
|
250 | } |
||
251 | |||
252 | /** |
||
253 | * Sets the cache driver implementation that is used for the query cache (SQL cache). |
||
254 | * |
||
255 | * @param \Doctrine\Common\Cache\Cache $cacheImpl |
||
256 | * |
||
257 | * @return void |
||
258 | */ |
||
259 | 2334 | public function setQueryCacheImpl(CacheDriver $cacheImpl) |
|
260 | { |
||
261 | 2334 | $this->_attributes['queryCacheImpl'] = $cacheImpl; |
|
262 | 2334 | } |
|
263 | |||
264 | /** |
||
265 | * Gets the cache driver implementation that is used for the hydration cache (SQL cache). |
||
266 | * |
||
267 | * @return \Doctrine\Common\Cache\Cache|null |
||
268 | */ |
||
269 | 1 | public function getHydrationCacheImpl() |
|
270 | { |
||
271 | 1 | return isset($this->_attributes['hydrationCacheImpl']) |
|
272 | 1 | ? $this->_attributes['hydrationCacheImpl'] |
|
273 | 1 | : null; |
|
274 | } |
||
275 | |||
276 | /** |
||
277 | * Sets the cache driver implementation that is used for the hydration cache (SQL cache). |
||
278 | * |
||
279 | * @param \Doctrine\Common\Cache\Cache $cacheImpl |
||
280 | * |
||
281 | * @return void |
||
282 | */ |
||
283 | 1 | public function setHydrationCacheImpl(CacheDriver $cacheImpl) |
|
284 | { |
||
285 | 1 | $this->_attributes['hydrationCacheImpl'] = $cacheImpl; |
|
286 | 1 | } |
|
287 | |||
288 | /** |
||
289 | * Gets the cache driver implementation that is used for metadata caching. |
||
290 | * |
||
291 | * @return \Doctrine\Common\Cache\Cache|null |
||
292 | */ |
||
293 | 2400 | public function getMetadataCacheImpl() |
|
294 | { |
||
295 | 2400 | return isset($this->_attributes['metadataCacheImpl']) |
|
296 | 2328 | ? $this->_attributes['metadataCacheImpl'] |
|
297 | 2400 | : null; |
|
298 | } |
||
299 | |||
300 | /** |
||
301 | * Sets the cache driver implementation that is used for metadata caching. |
||
302 | * |
||
303 | * @param \Doctrine\Common\Cache\Cache $cacheImpl |
||
304 | * |
||
305 | * @return void |
||
306 | */ |
||
307 | 2334 | public function setMetadataCacheImpl(CacheDriver $cacheImpl) |
|
308 | { |
||
309 | 2334 | $this->_attributes['metadataCacheImpl'] = $cacheImpl; |
|
310 | 2334 | } |
|
311 | |||
312 | /** |
||
313 | * Adds a named DQL query to the configuration. |
||
314 | * |
||
315 | * @param string $name The name of the query. |
||
316 | * @param string $dql The DQL query string. |
||
317 | * |
||
318 | * @return void |
||
319 | */ |
||
320 | 1 | public function addNamedQuery($name, $dql) |
|
321 | { |
||
322 | 1 | $this->_attributes['namedQueries'][$name] = $dql; |
|
323 | 1 | } |
|
324 | |||
325 | /** |
||
326 | * Gets a previously registered named DQL query. |
||
327 | * |
||
328 | * @param string $name The name of the query. |
||
329 | * |
||
330 | * @return string The DQL query. |
||
331 | * |
||
332 | * @throws ORMException |
||
333 | */ |
||
334 | 1 | public function getNamedQuery($name) |
|
335 | { |
||
336 | 1 | if ( ! isset($this->_attributes['namedQueries'][$name])) { |
|
337 | 1 | throw ORMException::namedQueryNotFound($name); |
|
338 | } |
||
339 | |||
340 | 1 | return $this->_attributes['namedQueries'][$name]; |
|
341 | } |
||
342 | |||
343 | /** |
||
344 | * Adds a named native query to the configuration. |
||
345 | * |
||
346 | * @param string $name The name of the query. |
||
347 | * @param string $sql The native SQL query string. |
||
348 | * @param Query\ResultSetMapping $rsm The ResultSetMapping used for the results of the SQL query. |
||
349 | * |
||
350 | * @return void |
||
351 | */ |
||
352 | 1 | public function addNamedNativeQuery($name, $sql, Query\ResultSetMapping $rsm) |
|
353 | { |
||
354 | 1 | $this->_attributes['namedNativeQueries'][$name] = [$sql, $rsm]; |
|
355 | 1 | } |
|
356 | |||
357 | /** |
||
358 | * Gets the components of a previously registered named native query. |
||
359 | * |
||
360 | * @param string $name The name of the query. |
||
361 | * |
||
362 | * @return array A tuple with the first element being the SQL string and the second |
||
363 | * element being the ResultSetMapping. |
||
364 | * |
||
365 | * @throws ORMException |
||
366 | */ |
||
367 | 1 | public function getNamedNativeQuery($name) |
|
368 | { |
||
369 | 1 | if ( ! isset($this->_attributes['namedNativeQueries'][$name])) { |
|
370 | 1 | throw ORMException::namedNativeQueryNotFound($name); |
|
371 | } |
||
372 | |||
373 | 1 | return $this->_attributes['namedNativeQueries'][$name]; |
|
374 | } |
||
375 | |||
376 | /** |
||
377 | * Ensures that this Configuration instance contains settings that are |
||
378 | * suitable for a production environment. |
||
379 | * |
||
380 | * @return void |
||
381 | * |
||
382 | * @throws ORMException If a configuration setting has a value that is not |
||
383 | * suitable for a production environment. |
||
384 | */ |
||
385 | 8 | public function ensureProductionSettings() |
|
386 | { |
||
387 | 8 | $queryCacheImpl = $this->getQueryCacheImpl(); |
|
388 | |||
389 | 8 | if ( ! $queryCacheImpl) { |
|
390 | 1 | throw ORMException::queryCacheNotConfigured(); |
|
391 | } |
||
392 | |||
393 | 7 | if ($queryCacheImpl instanceof ArrayCache) { |
|
394 | 1 | throw ORMException::queryCacheUsesNonPersistentCache($queryCacheImpl); |
|
395 | } |
||
396 | |||
397 | 6 | $metadataCacheImpl = $this->getMetadataCacheImpl(); |
|
398 | |||
399 | 6 | if ( ! $metadataCacheImpl) { |
|
400 | 1 | throw ORMException::metadataCacheNotConfigured(); |
|
401 | } |
||
402 | |||
403 | 5 | if ($metadataCacheImpl instanceof ArrayCache) { |
|
404 | 1 | throw ORMException::metadataCacheUsesNonPersistentCache($metadataCacheImpl); |
|
405 | } |
||
406 | |||
407 | 4 | if ($this->getAutoGenerateProxyClasses()) { |
|
408 | 3 | throw ORMException::proxyClassesAlwaysRegenerating(); |
|
409 | } |
||
410 | 1 | } |
|
411 | |||
412 | /** |
||
413 | * Registers a custom DQL function that produces a string value. |
||
414 | * Such a function can then be used in any DQL statement in any place where string |
||
415 | * functions are allowed. |
||
416 | * |
||
417 | * DQL function names are case-insensitive. |
||
418 | * |
||
419 | * @param string $name Function name. |
||
420 | * @param string|callable $className Class name or a callable that returns the function. |
||
421 | * |
||
422 | * @return void |
||
423 | */ |
||
424 | 4 | public function addCustomStringFunction($name, $className) |
|
425 | { |
||
426 | 4 | $this->_attributes['customStringFunctions'][strtolower($name)] = $className; |
|
427 | 4 | } |
|
428 | |||
429 | /** |
||
430 | * Gets the implementation class name of a registered custom string DQL function. |
||
431 | * |
||
432 | * @param string $name |
||
433 | * |
||
434 | * @return string|null |
||
435 | */ |
||
436 | 142 | View Code Duplication | public function getCustomStringFunction($name) |
437 | { |
||
438 | 142 | $name = strtolower($name); |
|
439 | |||
440 | 142 | return isset($this->_attributes['customStringFunctions'][$name]) |
|
441 | 4 | ? $this->_attributes['customStringFunctions'][$name] |
|
442 | 142 | : null; |
|
443 | } |
||
444 | |||
445 | /** |
||
446 | * Sets a map of custom DQL string functions. |
||
447 | * |
||
448 | * Keys must be function names and values the FQCN of the implementing class. |
||
449 | * The function names will be case-insensitive in DQL. |
||
450 | * |
||
451 | * Any previously added string functions are discarded. |
||
452 | * |
||
453 | * @param array $functions The map of custom DQL string functions. |
||
454 | * |
||
455 | * @return void |
||
456 | */ |
||
457 | 1 | public function setCustomStringFunctions(array $functions) |
|
458 | { |
||
459 | 1 | foreach ($functions as $name => $className) { |
|
460 | 1 | $this->addCustomStringFunction($name, $className); |
|
461 | } |
||
462 | 1 | } |
|
463 | |||
464 | /** |
||
465 | * Registers a custom DQL function that produces a numeric value. |
||
466 | * Such a function can then be used in any DQL statement in any place where numeric |
||
467 | * functions are allowed. |
||
468 | * |
||
469 | * DQL function names are case-insensitive. |
||
470 | * |
||
471 | * @param string $name Function name. |
||
472 | * @param string|callable $className Class name or a callable that returns the function. |
||
473 | * |
||
474 | * @return void |
||
475 | */ |
||
476 | 3 | public function addCustomNumericFunction($name, $className) |
|
477 | { |
||
478 | 3 | $this->_attributes['customNumericFunctions'][strtolower($name)] = $className; |
|
479 | 3 | } |
|
480 | |||
481 | /** |
||
482 | * Gets the implementation class name of a registered custom numeric DQL function. |
||
483 | * |
||
484 | * @param string $name |
||
485 | * |
||
486 | * @return string|null |
||
487 | */ |
||
488 | 140 | View Code Duplication | public function getCustomNumericFunction($name) |
489 | { |
||
490 | 140 | $name = strtolower($name); |
|
491 | |||
492 | 140 | return isset($this->_attributes['customNumericFunctions'][$name]) |
|
493 | 3 | ? $this->_attributes['customNumericFunctions'][$name] |
|
494 | 140 | : null; |
|
495 | } |
||
496 | |||
497 | /** |
||
498 | * Sets a map of custom DQL numeric functions. |
||
499 | * |
||
500 | * Keys must be function names and values the FQCN of the implementing class. |
||
501 | * The function names will be case-insensitive in DQL. |
||
502 | * |
||
503 | * Any previously added numeric functions are discarded. |
||
504 | * |
||
505 | * @param array $functions The map of custom DQL numeric functions. |
||
506 | * |
||
507 | * @return void |
||
508 | */ |
||
509 | 2 | public function setCustomNumericFunctions(array $functions) |
|
510 | { |
||
511 | 2 | foreach ($functions as $name => $className) { |
|
512 | 1 | $this->addCustomNumericFunction($name, $className); |
|
513 | } |
||
514 | 2 | } |
|
515 | |||
516 | /** |
||
517 | * Registers a custom DQL function that produces a date/time value. |
||
518 | * Such a function can then be used in any DQL statement in any place where date/time |
||
519 | * functions are allowed. |
||
520 | * |
||
521 | * DQL function names are case-insensitive. |
||
522 | * |
||
523 | * @param string $name Function name. |
||
524 | * @param string|callable $className Class name or a callable that returns the function. |
||
525 | * |
||
526 | * @return void |
||
527 | */ |
||
528 | 1 | public function addCustomDatetimeFunction($name, $className) |
|
529 | { |
||
530 | 1 | $this->_attributes['customDatetimeFunctions'][strtolower($name)] = $className; |
|
531 | 1 | } |
|
532 | |||
533 | /** |
||
534 | * Gets the implementation class name of a registered custom date/time DQL function. |
||
535 | * |
||
536 | * @param string $name |
||
537 | * |
||
538 | * @return string|null |
||
539 | */ |
||
540 | 138 | View Code Duplication | public function getCustomDatetimeFunction($name) |
541 | { |
||
542 | 138 | $name = strtolower($name); |
|
543 | |||
544 | 138 | return isset($this->_attributes['customDatetimeFunctions'][$name]) |
|
545 | 1 | ? $this->_attributes['customDatetimeFunctions'][$name] |
|
546 | 138 | : null; |
|
547 | } |
||
548 | |||
549 | /** |
||
550 | * Sets a map of custom DQL date/time functions. |
||
551 | * |
||
552 | * Keys must be function names and values the FQCN of the implementing class. |
||
553 | * The function names will be case-insensitive in DQL. |
||
554 | * |
||
555 | * Any previously added date/time functions are discarded. |
||
556 | * |
||
557 | * @param array $functions The map of custom DQL date/time functions. |
||
558 | * |
||
559 | * @return void |
||
560 | */ |
||
561 | 1 | public function setCustomDatetimeFunctions(array $functions) |
|
562 | { |
||
563 | 1 | foreach ($functions as $name => $className) { |
|
564 | 1 | $this->addCustomDatetimeFunction($name, $className); |
|
565 | } |
||
566 | 1 | } |
|
567 | |||
568 | /** |
||
569 | * Sets the custom hydrator modes in one pass. |
||
570 | * |
||
571 | * @param array $modes An array of ($modeName => $hydrator). |
||
572 | * |
||
573 | * @return void |
||
574 | */ |
||
575 | 1 | public function setCustomHydrationModes($modes) |
|
576 | { |
||
577 | 1 | $this->_attributes['customHydrationModes'] = []; |
|
578 | |||
579 | 1 | foreach ($modes as $modeName => $hydrator) { |
|
580 | 1 | $this->addCustomHydrationMode($modeName, $hydrator); |
|
581 | } |
||
582 | 1 | } |
|
583 | |||
584 | /** |
||
585 | * Gets the hydrator class for the given hydration mode name. |
||
586 | * |
||
587 | * @param string $modeName The hydration mode name. |
||
588 | * |
||
589 | * @return string|null The hydrator class name. |
||
590 | */ |
||
591 | 3 | public function getCustomHydrationMode($modeName) |
|
592 | { |
||
593 | 3 | return isset($this->_attributes['customHydrationModes'][$modeName]) |
|
594 | 3 | ? $this->_attributes['customHydrationModes'][$modeName] |
|
595 | 3 | : null; |
|
596 | } |
||
597 | |||
598 | /** |
||
599 | * Adds a custom hydration mode. |
||
600 | * |
||
601 | * @param string $modeName The hydration mode name. |
||
602 | * @param string $hydrator The hydrator class name. |
||
603 | * |
||
604 | * @return void |
||
605 | */ |
||
606 | 3 | public function addCustomHydrationMode($modeName, $hydrator) |
|
607 | { |
||
608 | 3 | $this->_attributes['customHydrationModes'][$modeName] = $hydrator; |
|
609 | 3 | } |
|
610 | |||
611 | /** |
||
612 | * Sets a class metadata factory. |
||
613 | * |
||
614 | * @param string $cmfName |
||
615 | * |
||
616 | * @return void |
||
617 | */ |
||
618 | 1 | public function setClassMetadataFactoryName($cmfName) |
|
619 | { |
||
620 | 1 | $this->_attributes['classMetadataFactoryName'] = $cmfName; |
|
621 | 1 | } |
|
622 | |||
623 | /** |
||
624 | * @return string |
||
625 | */ |
||
626 | 2392 | public function getClassMetadataFactoryName() |
|
627 | { |
||
628 | 2392 | if ( ! isset($this->_attributes['classMetadataFactoryName'])) { |
|
629 | 2392 | $this->_attributes['classMetadataFactoryName'] = ClassMetadataFactory::class; |
|
630 | } |
||
631 | |||
632 | 2392 | return $this->_attributes['classMetadataFactoryName']; |
|
633 | } |
||
634 | |||
635 | /** |
||
636 | * Adds a filter to the list of possible filters. |
||
637 | * |
||
638 | * @param string $name The name of the filter. |
||
639 | * @param string $className The class name of the filter. |
||
640 | */ |
||
641 | 46 | public function addFilter($name, $className) |
|
642 | { |
||
643 | 46 | $this->_attributes['filters'][$name] = $className; |
|
644 | 46 | } |
|
645 | |||
646 | /** |
||
647 | * Gets the class name for a given filter name. |
||
648 | * |
||
649 | * @param string $name The name of the filter. |
||
650 | * |
||
651 | * @return string The class name of the filter, or null if it is not |
||
652 | * defined. |
||
653 | */ |
||
654 | 45 | public function getFilterClassName($name) |
|
655 | { |
||
656 | 45 | return isset($this->_attributes['filters'][$name]) |
|
657 | 45 | ? $this->_attributes['filters'][$name] |
|
658 | 45 | : null; |
|
659 | } |
||
660 | |||
661 | /** |
||
662 | * Sets default repository class. |
||
663 | * |
||
664 | * @since 2.2 |
||
665 | * |
||
666 | * @param string $className |
||
667 | * |
||
668 | * @return void |
||
669 | * |
||
670 | * @throws ORMException If not is a \Doctrine\Common\Persistence\ObjectRepository |
||
671 | */ |
||
672 | 3 | public function setDefaultRepositoryClassName($className) |
|
673 | { |
||
674 | 3 | $reflectionClass = new \ReflectionClass($className); |
|
675 | |||
676 | 3 | if ( ! $reflectionClass->implementsInterface(ObjectRepository::class)) { |
|
677 | 1 | throw ORMException::invalidEntityRepository($className); |
|
678 | } |
||
679 | |||
680 | 2 | $this->_attributes['defaultRepositoryClassName'] = $className; |
|
681 | 2 | } |
|
682 | |||
683 | /** |
||
684 | * Get default repository class. |
||
685 | * |
||
686 | * @since 2.2 |
||
687 | * |
||
688 | * @return string |
||
689 | */ |
||
690 | 150 | public function getDefaultRepositoryClassName() |
|
691 | { |
||
692 | 150 | return isset($this->_attributes['defaultRepositoryClassName']) |
|
693 | 2 | ? $this->_attributes['defaultRepositoryClassName'] |
|
694 | 150 | : EntityRepository::class; |
|
695 | } |
||
696 | |||
697 | /** |
||
698 | * Sets naming strategy. |
||
699 | * |
||
700 | * @since 2.3 |
||
701 | * |
||
702 | * @param NamingStrategy $namingStrategy |
||
703 | * |
||
704 | * @return void |
||
705 | */ |
||
706 | 7 | public function setNamingStrategy(NamingStrategy $namingStrategy) |
|
707 | { |
||
708 | 7 | $this->_attributes['namingStrategy'] = $namingStrategy; |
|
709 | 7 | } |
|
710 | |||
711 | /** |
||
712 | * Gets naming strategy.. |
||
713 | * |
||
714 | * @since 2.3 |
||
715 | * |
||
716 | * @return NamingStrategy |
||
717 | */ |
||
718 | 451 | public function getNamingStrategy() |
|
719 | { |
||
720 | 451 | if ( ! isset($this->_attributes['namingStrategy'])) { |
|
721 | 451 | $this->_attributes['namingStrategy'] = new DefaultNamingStrategy(); |
|
722 | } |
||
723 | |||
724 | 451 | return $this->_attributes['namingStrategy']; |
|
725 | } |
||
726 | |||
727 | /** |
||
728 | * Sets quote strategy. |
||
729 | * |
||
730 | * @since 2.3 |
||
731 | * |
||
732 | * @param \Doctrine\ORM\Mapping\QuoteStrategy $quoteStrategy |
||
733 | * |
||
734 | * @return void |
||
735 | */ |
||
736 | 2 | public function setQuoteStrategy(QuoteStrategy $quoteStrategy) |
|
737 | { |
||
738 | 2 | $this->_attributes['quoteStrategy'] = $quoteStrategy; |
|
739 | 2 | } |
|
740 | |||
741 | /** |
||
742 | * Gets quote strategy. |
||
743 | * |
||
744 | * @since 2.3 |
||
745 | * |
||
746 | * @return \Doctrine\ORM\Mapping\QuoteStrategy |
||
747 | */ |
||
748 | 1643 | public function getQuoteStrategy() |
|
749 | { |
||
750 | 1643 | if ( ! isset($this->_attributes['quoteStrategy'])) { |
|
751 | 1643 | $this->_attributes['quoteStrategy'] = new DefaultQuoteStrategy(); |
|
752 | } |
||
753 | |||
754 | 1643 | return $this->_attributes['quoteStrategy']; |
|
755 | } |
||
756 | |||
757 | /** |
||
758 | * Set the entity listener resolver. |
||
759 | * |
||
760 | * @since 2.4 |
||
761 | * @param \Doctrine\ORM\Mapping\EntityListenerResolver $resolver |
||
762 | */ |
||
763 | 1 | public function setEntityListenerResolver(EntityListenerResolver $resolver) |
|
764 | { |
||
765 | 1 | $this->_attributes['entityListenerResolver'] = $resolver; |
|
766 | 1 | } |
|
767 | |||
768 | /** |
||
769 | * Get the entity listener resolver. |
||
770 | * |
||
771 | * @since 2.4 |
||
772 | * @return \Doctrine\ORM\Mapping\EntityListenerResolver |
||
773 | */ |
||
774 | 2392 | public function getEntityListenerResolver() |
|
775 | { |
||
776 | 2392 | if ( ! isset($this->_attributes['entityListenerResolver'])) { |
|
777 | 2392 | $this->_attributes['entityListenerResolver'] = new DefaultEntityListenerResolver(); |
|
778 | } |
||
779 | |||
780 | 2392 | return $this->_attributes['entityListenerResolver']; |
|
781 | } |
||
782 | |||
783 | /** |
||
784 | * Set the entity repository factory. |
||
785 | * |
||
786 | * @since 2.4 |
||
787 | * @param \Doctrine\ORM\Repository\RepositoryFactory $repositoryFactory |
||
788 | */ |
||
789 | public function setRepositoryFactory(RepositoryFactory $repositoryFactory) |
||
790 | { |
||
791 | $this->_attributes['repositoryFactory'] = $repositoryFactory; |
||
792 | } |
||
793 | |||
794 | /** |
||
795 | * Get the entity repository factory. |
||
796 | * |
||
797 | * @since 2.4 |
||
798 | * @return \Doctrine\ORM\Repository\RepositoryFactory |
||
799 | */ |
||
800 | 2391 | public function getRepositoryFactory() |
|
801 | { |
||
802 | 2391 | return isset($this->_attributes['repositoryFactory']) |
|
803 | ? $this->_attributes['repositoryFactory'] |
||
804 | 2391 | : new DefaultRepositoryFactory(); |
|
805 | } |
||
806 | |||
807 | /** |
||
808 | * @since 2.5 |
||
809 | * |
||
810 | * @return boolean |
||
811 | */ |
||
812 | 2392 | public function isSecondLevelCacheEnabled() |
|
813 | { |
||
814 | 2392 | return isset($this->_attributes['isSecondLevelCacheEnabled']) |
|
815 | 283 | ? $this->_attributes['isSecondLevelCacheEnabled'] |
|
816 | 2392 | : false; |
|
817 | } |
||
818 | |||
819 | /** |
||
820 | * @since 2.5 |
||
821 | * |
||
822 | * @param boolean $flag |
||
823 | * |
||
824 | * @return void |
||
825 | */ |
||
826 | 283 | public function setSecondLevelCacheEnabled($flag = true) |
|
827 | { |
||
828 | 283 | $this->_attributes['isSecondLevelCacheEnabled'] = (boolean) $flag; |
|
829 | 283 | } |
|
830 | |||
831 | /** |
||
832 | * @since 2.5 |
||
833 | * |
||
834 | * @param \Doctrine\ORM\Cache\CacheConfiguration $cacheConfig |
||
835 | * |
||
836 | * @return void |
||
837 | */ |
||
838 | 284 | public function setSecondLevelCacheConfiguration(CacheConfiguration $cacheConfig) |
|
839 | { |
||
840 | 284 | $this->_attributes['secondLevelCacheConfiguration'] = $cacheConfig; |
|
841 | 284 | } |
|
842 | |||
843 | /** |
||
844 | * @since 2.5 |
||
845 | * |
||
846 | * @return \Doctrine\ORM\Cache\CacheConfiguration|null |
||
847 | */ |
||
848 | 284 | public function getSecondLevelCacheConfiguration() |
|
849 | { |
||
850 | 284 | if ( ! isset($this->_attributes['secondLevelCacheConfiguration']) && $this->isSecondLevelCacheEnabled()) { |
|
851 | $this->_attributes['secondLevelCacheConfiguration'] = new CacheConfiguration(); |
||
852 | } |
||
853 | |||
854 | 284 | return isset($this->_attributes['secondLevelCacheConfiguration']) |
|
855 | 284 | ? $this->_attributes['secondLevelCacheConfiguration'] |
|
856 | 284 | : null; |
|
857 | } |
||
858 | |||
859 | /** |
||
860 | * Returns query hints, which will be applied to every query in application |
||
861 | * |
||
862 | * @since 2.5 |
||
863 | * |
||
864 | * @return array |
||
865 | */ |
||
866 | 959 | public function getDefaultQueryHints() |
|
867 | { |
||
868 | 959 | return isset($this->_attributes['defaultQueryHints']) ? $this->_attributes['defaultQueryHints'] : []; |
|
869 | } |
||
870 | |||
871 | /** |
||
872 | * Sets array of query hints, which will be applied to every query in application |
||
873 | * |
||
874 | * @since 2.5 |
||
875 | * |
||
876 | * @param array $defaultQueryHints |
||
877 | */ |
||
878 | 1 | public function setDefaultQueryHints(array $defaultQueryHints) |
|
879 | { |
||
880 | 1 | $this->_attributes['defaultQueryHints'] = $defaultQueryHints; |
|
881 | 1 | } |
|
882 | |||
883 | /** |
||
884 | * Gets the value of a default query hint. If the hint name is not recognized, FALSE is returned. |
||
885 | * |
||
886 | * @since 2.5 |
||
887 | * |
||
888 | * @param string $name The name of the hint. |
||
889 | * |
||
890 | * @return mixed The value of the hint or FALSE, if the hint name is not recognized. |
||
891 | */ |
||
892 | public function getDefaultQueryHint($name) |
||
893 | { |
||
894 | return isset($this->_attributes['defaultQueryHints'][$name]) |
||
895 | ? $this->_attributes['defaultQueryHints'][$name] |
||
896 | : false; |
||
897 | } |
||
898 | |||
899 | /** |
||
900 | * Sets a default query hint. If the hint name is not recognized, it is silently ignored. |
||
901 | * |
||
902 | * @since 2.5 |
||
903 | * |
||
904 | * @param string $name The name of the hint. |
||
905 | * @param mixed $value The value of the hint. |
||
906 | */ |
||
907 | 1 | public function setDefaultQueryHint($name, $value) |
|
908 | { |
||
909 | 1 | $this->_attributes['defaultQueryHints'][$name] = $value; |
|
910 | 1 | } |
|
911 | } |
||
912 |
This method has been deprecated. The supplier of the class has supplied an explanatory message.
The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead.