doctrine /
mongodb-odm
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like ClassMetadataInfo often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use ClassMetadataInfo, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 44 | class ClassMetadataInfo implements \Doctrine\Common\Persistence\Mapping\ClassMetadata |
||
| 45 | { |
||
| 46 | /* The Id generator types. */ |
||
| 47 | /** |
||
| 48 | * AUTO means Doctrine will automatically create a new \MongoId instance for us. |
||
| 49 | */ |
||
| 50 | const GENERATOR_TYPE_AUTO = 1; |
||
| 51 | |||
| 52 | /** |
||
| 53 | * INCREMENT means a separate collection is used for maintaining and incrementing id generation. |
||
| 54 | * Offers full portability. |
||
| 55 | */ |
||
| 56 | const GENERATOR_TYPE_INCREMENT = 2; |
||
| 57 | |||
| 58 | /** |
||
| 59 | * UUID means Doctrine will generate a uuid for us. |
||
| 60 | */ |
||
| 61 | const GENERATOR_TYPE_UUID = 3; |
||
| 62 | |||
| 63 | /** |
||
| 64 | * ALNUM means Doctrine will generate Alpha-numeric string identifiers, using the INCREMENT |
||
| 65 | * generator to ensure identifier uniqueness |
||
| 66 | */ |
||
| 67 | const GENERATOR_TYPE_ALNUM = 4; |
||
| 68 | |||
| 69 | /** |
||
| 70 | * CUSTOM means Doctrine expect a class parameter. It will then try to initiate that class |
||
| 71 | * and pass other options to the generator. It will throw an Exception if the class |
||
| 72 | * does not exist or if an option was passed for that there is not setter in the new |
||
| 73 | * generator class. |
||
| 74 | * |
||
| 75 | * The class will have to be a subtype of AbstractIdGenerator. |
||
| 76 | */ |
||
| 77 | const GENERATOR_TYPE_CUSTOM = 5; |
||
| 78 | |||
| 79 | /** |
||
| 80 | * NONE means Doctrine will not generate any id for us and you are responsible for manually |
||
| 81 | * assigning an id. |
||
| 82 | */ |
||
| 83 | const GENERATOR_TYPE_NONE = 6; |
||
| 84 | |||
| 85 | /** |
||
| 86 | * Default discriminator field name. |
||
| 87 | * |
||
| 88 | * This is used for associations value for associations where a that do not define a "targetDocument" or |
||
| 89 | * "discriminatorField" option in their mapping. |
||
| 90 | */ |
||
| 91 | const DEFAULT_DISCRIMINATOR_FIELD = '_doctrine_class_name'; |
||
| 92 | |||
| 93 | const REFERENCE_ONE = 1; |
||
| 94 | const REFERENCE_MANY = 2; |
||
| 95 | const EMBED_ONE = 3; |
||
| 96 | const EMBED_MANY = 4; |
||
| 97 | const MANY = 'many'; |
||
| 98 | const ONE = 'one'; |
||
| 99 | |||
| 100 | /**#@+ |
||
| 101 | * The types of storeAs references |
||
| 102 | */ |
||
| 103 | const REFERENCE_STORE_AS_ID = 'id'; |
||
| 104 | const REFERENCE_STORE_AS_DB_REF = 'dbRef'; |
||
| 105 | const REFERENCE_STORE_AS_DB_REF_WITH_DB = 'dbRefWithDb'; |
||
| 106 | /**#@-*/ |
||
| 107 | |||
| 108 | /* The inheritance mapping types */ |
||
| 109 | /** |
||
| 110 | * NONE means the class does not participate in an inheritance hierarchy |
||
| 111 | * and therefore does not need an inheritance mapping type. |
||
| 112 | */ |
||
| 113 | const INHERITANCE_TYPE_NONE = 1; |
||
| 114 | |||
| 115 | /** |
||
| 116 | * SINGLE_COLLECTION means the class will be persisted according to the rules of |
||
| 117 | * <tt>Single Collection Inheritance</tt>. |
||
| 118 | */ |
||
| 119 | const INHERITANCE_TYPE_SINGLE_COLLECTION = 2; |
||
| 120 | |||
| 121 | /** |
||
| 122 | * COLLECTION_PER_CLASS means the class will be persisted according to the rules |
||
| 123 | * of <tt>Concrete Collection Inheritance</tt>. |
||
| 124 | */ |
||
| 125 | const INHERITANCE_TYPE_COLLECTION_PER_CLASS = 3; |
||
| 126 | |||
| 127 | /** |
||
| 128 | * DEFERRED_IMPLICIT means that changes of entities are calculated at commit-time |
||
| 129 | * by doing a property-by-property comparison with the original data. This will |
||
| 130 | * be done for all entities that are in MANAGED state at commit-time. |
||
| 131 | * |
||
| 132 | * This is the default change tracking policy. |
||
| 133 | */ |
||
| 134 | const CHANGETRACKING_DEFERRED_IMPLICIT = 1; |
||
| 135 | |||
| 136 | /** |
||
| 137 | * DEFERRED_EXPLICIT means that changes of entities are calculated at commit-time |
||
| 138 | * by doing a property-by-property comparison with the original data. This will |
||
| 139 | * be done only for entities that were explicitly saved (through persist() or a cascade). |
||
| 140 | */ |
||
| 141 | const CHANGETRACKING_DEFERRED_EXPLICIT = 2; |
||
| 142 | |||
| 143 | /** |
||
| 144 | * NOTIFY means that Doctrine relies on the entities sending out notifications |
||
| 145 | * when their properties change. Such entity classes must implement |
||
| 146 | * the <tt>NotifyPropertyChanged</tt> interface. |
||
| 147 | */ |
||
| 148 | const CHANGETRACKING_NOTIFY = 3; |
||
| 149 | |||
| 150 | /** |
||
| 151 | * SET means that fields will be written to the database using a $set operator |
||
| 152 | */ |
||
| 153 | const STORAGE_STRATEGY_SET = 'set'; |
||
| 154 | |||
| 155 | /** |
||
| 156 | * INCREMENT means that fields will be written to the database by calculating |
||
| 157 | * the difference and using the $inc operator |
||
| 158 | */ |
||
| 159 | const STORAGE_STRATEGY_INCREMENT = 'increment'; |
||
| 160 | |||
| 161 | const STORAGE_STRATEGY_PUSH_ALL = 'pushAll'; |
||
| 162 | const STORAGE_STRATEGY_ADD_TO_SET = 'addToSet'; |
||
| 163 | const STORAGE_STRATEGY_ATOMIC_SET = 'atomicSet'; |
||
| 164 | const STORAGE_STRATEGY_ATOMIC_SET_ARRAY = 'atomicSetArray'; |
||
| 165 | const STORAGE_STRATEGY_SET_ARRAY = 'setArray'; |
||
| 166 | |||
| 167 | /** |
||
| 168 | * READ-ONLY: The name of the mongo database the document is mapped to. |
||
| 169 | */ |
||
| 170 | public $db; |
||
| 171 | |||
| 172 | /** |
||
| 173 | * READ-ONLY: The name of the mongo collection the document is mapped to. |
||
| 174 | */ |
||
| 175 | public $collection; |
||
| 176 | |||
| 177 | /** |
||
| 178 | * READ-ONLY: If the collection should be a fixed size. |
||
| 179 | */ |
||
| 180 | public $collectionCapped; |
||
| 181 | |||
| 182 | /** |
||
| 183 | * READ-ONLY: If the collection is fixed size, its size in bytes. |
||
| 184 | */ |
||
| 185 | public $collectionSize; |
||
| 186 | |||
| 187 | /** |
||
| 188 | * READ-ONLY: If the collection is fixed size, the maximum number of elements to store in the collection. |
||
| 189 | */ |
||
| 190 | public $collectionMax; |
||
| 191 | |||
| 192 | /** |
||
| 193 | * READ-ONLY: The field name of the document identifier. |
||
| 194 | */ |
||
| 195 | public $identifier; |
||
| 196 | |||
| 197 | /** |
||
| 198 | * READ-ONLY: The field that stores a file reference and indicates the |
||
| 199 | * document is a file and should be stored on the MongoGridFS. |
||
| 200 | */ |
||
| 201 | public $file; |
||
| 202 | |||
| 203 | /** |
||
| 204 | * READ-ONLY: The field that stores the calculated distance when performing geo spatial |
||
| 205 | * queries. |
||
| 206 | */ |
||
| 207 | public $distance; |
||
| 208 | |||
| 209 | /** |
||
| 210 | * READ-ONLY: Whether or not reads for this class are okay to read from a slave. |
||
| 211 | */ |
||
| 212 | public $slaveOkay; |
||
| 213 | |||
| 214 | /** |
||
| 215 | * READ-ONLY: The array of indexes for the document collection. |
||
| 216 | */ |
||
| 217 | public $indexes = array(); |
||
| 218 | |||
| 219 | /** |
||
| 220 | * READ-ONLY: Whether or not queries on this document should require indexes. |
||
| 221 | */ |
||
| 222 | public $requireIndexes = false; |
||
| 223 | |||
| 224 | /** |
||
| 225 | * READ-ONLY: The name of the document class. |
||
| 226 | */ |
||
| 227 | public $name; |
||
| 228 | |||
| 229 | /** |
||
| 230 | * READ-ONLY: The namespace the document class is contained in. |
||
| 231 | * |
||
| 232 | * @var string |
||
| 233 | * @todo Not really needed. Usage could be localized. |
||
| 234 | */ |
||
| 235 | public $namespace; |
||
| 236 | |||
| 237 | /** |
||
| 238 | * READ-ONLY: The name of the document class that is at the root of the mapped document inheritance |
||
| 239 | * hierarchy. If the document is not part of a mapped inheritance hierarchy this is the same |
||
| 240 | * as {@link $documentName}. |
||
| 241 | * |
||
| 242 | * @var string |
||
| 243 | */ |
||
| 244 | public $rootDocumentName; |
||
| 245 | |||
| 246 | /** |
||
| 247 | * The name of the custom repository class used for the document class. |
||
| 248 | * (Optional). |
||
| 249 | * |
||
| 250 | * @var string |
||
| 251 | */ |
||
| 252 | public $customRepositoryClassName; |
||
| 253 | |||
| 254 | /** |
||
| 255 | * READ-ONLY: The names of the parent classes (ancestors). |
||
| 256 | * |
||
| 257 | * @var array |
||
| 258 | */ |
||
| 259 | public $parentClasses = array(); |
||
| 260 | |||
| 261 | /** |
||
| 262 | * READ-ONLY: The names of all subclasses (descendants). |
||
| 263 | * |
||
| 264 | * @var array |
||
| 265 | */ |
||
| 266 | public $subClasses = array(); |
||
| 267 | |||
| 268 | /** |
||
| 269 | * The ReflectionProperty instances of the mapped class. |
||
| 270 | * |
||
| 271 | * @var \ReflectionProperty[] |
||
| 272 | */ |
||
| 273 | public $reflFields = array(); |
||
| 274 | |||
| 275 | /** |
||
| 276 | * READ-ONLY: The inheritance mapping type used by the class. |
||
| 277 | * |
||
| 278 | * @var integer |
||
| 279 | */ |
||
| 280 | public $inheritanceType = self::INHERITANCE_TYPE_NONE; |
||
| 281 | |||
| 282 | /** |
||
| 283 | * READ-ONLY: The Id generator type used by the class. |
||
| 284 | * |
||
| 285 | * @var string |
||
| 286 | */ |
||
| 287 | public $generatorType = self::GENERATOR_TYPE_AUTO; |
||
| 288 | |||
| 289 | /** |
||
| 290 | * READ-ONLY: The Id generator options. |
||
| 291 | * |
||
| 292 | * @var array |
||
| 293 | */ |
||
| 294 | public $generatorOptions = array(); |
||
| 295 | |||
| 296 | /** |
||
| 297 | * READ-ONLY: The ID generator used for generating IDs for this class. |
||
| 298 | * |
||
| 299 | * @var \Doctrine\ODM\MongoDB\Id\AbstractIdGenerator |
||
| 300 | */ |
||
| 301 | public $idGenerator; |
||
| 302 | |||
| 303 | /** |
||
| 304 | * READ-ONLY: The field mappings of the class. |
||
| 305 | * Keys are field names and values are mapping definitions. |
||
| 306 | * |
||
| 307 | * The mapping definition array has the following values: |
||
| 308 | * |
||
| 309 | * - <b>fieldName</b> (string) |
||
| 310 | * The name of the field in the Document. |
||
| 311 | * |
||
| 312 | * - <b>id</b> (boolean, optional) |
||
| 313 | * Marks the field as the primary key of the document. Multiple fields of an |
||
| 314 | * document can have the id attribute, forming a composite key. |
||
| 315 | * |
||
| 316 | * @var array |
||
| 317 | */ |
||
| 318 | public $fieldMappings = array(); |
||
| 319 | |||
| 320 | /** |
||
| 321 | * READ-ONLY: The association mappings of the class. |
||
| 322 | * Keys are field names and values are mapping definitions. |
||
| 323 | * |
||
| 324 | * @var array |
||
| 325 | */ |
||
| 326 | public $associationMappings = array(); |
||
| 327 | |||
| 328 | /** |
||
| 329 | * READ-ONLY: Array of fields to also load with a given method. |
||
| 330 | * |
||
| 331 | * @var array |
||
| 332 | */ |
||
| 333 | public $alsoLoadMethods = array(); |
||
| 334 | |||
| 335 | /** |
||
| 336 | * READ-ONLY: The registered lifecycle callbacks for documents of this class. |
||
| 337 | * |
||
| 338 | * @var array |
||
| 339 | */ |
||
| 340 | public $lifecycleCallbacks = array(); |
||
| 341 | |||
| 342 | /** |
||
| 343 | * READ-ONLY: The discriminator value of this class. |
||
| 344 | * |
||
| 345 | * <b>This does only apply to the JOINED and SINGLE_COLLECTION inheritance mapping strategies |
||
| 346 | * where a discriminator field is used.</b> |
||
| 347 | * |
||
| 348 | * @var mixed |
||
| 349 | * @see discriminatorField |
||
| 350 | */ |
||
| 351 | public $discriminatorValue; |
||
| 352 | |||
| 353 | /** |
||
| 354 | * READ-ONLY: The discriminator map of all mapped classes in the hierarchy. |
||
| 355 | * |
||
| 356 | * <b>This does only apply to the SINGLE_COLLECTION inheritance mapping strategy |
||
| 357 | * where a discriminator field is used.</b> |
||
| 358 | * |
||
| 359 | * @var mixed |
||
| 360 | * @see discriminatorField |
||
| 361 | */ |
||
| 362 | public $discriminatorMap = array(); |
||
| 363 | |||
| 364 | /** |
||
| 365 | * READ-ONLY: The definition of the discriminator field used in SINGLE_COLLECTION |
||
| 366 | * inheritance mapping. |
||
| 367 | * |
||
| 368 | * @var string |
||
| 369 | */ |
||
| 370 | public $discriminatorField; |
||
| 371 | |||
| 372 | /** |
||
| 373 | * READ-ONLY: The default value for discriminatorField in case it's not set in the document |
||
| 374 | * |
||
| 375 | * @var string |
||
| 376 | * @see discriminatorField |
||
| 377 | */ |
||
| 378 | public $defaultDiscriminatorValue; |
||
| 379 | |||
| 380 | /** |
||
| 381 | * READ-ONLY: Whether this class describes the mapping of a mapped superclass. |
||
| 382 | * |
||
| 383 | * @var boolean |
||
| 384 | */ |
||
| 385 | public $isMappedSuperclass = false; |
||
| 386 | |||
| 387 | /** |
||
| 388 | * READ-ONLY: Whether this class describes the mapping of a embedded document. |
||
| 389 | * |
||
| 390 | * @var boolean |
||
| 391 | */ |
||
| 392 | public $isEmbeddedDocument = false; |
||
| 393 | |||
| 394 | /** |
||
| 395 | * READ-ONLY: The policy used for change-tracking on entities of this class. |
||
| 396 | * |
||
| 397 | * @var integer |
||
| 398 | */ |
||
| 399 | public $changeTrackingPolicy = self::CHANGETRACKING_DEFERRED_IMPLICIT; |
||
| 400 | |||
| 401 | /** |
||
| 402 | * READ-ONLY: A flag for whether or not instances of this class are to be versioned |
||
| 403 | * with optimistic locking. |
||
| 404 | * |
||
| 405 | * @var boolean $isVersioned |
||
| 406 | */ |
||
| 407 | public $isVersioned; |
||
| 408 | |||
| 409 | /** |
||
| 410 | * READ-ONLY: The name of the field which is used for versioning in optimistic locking (if any). |
||
| 411 | * |
||
| 412 | * @var mixed $versionField |
||
| 413 | */ |
||
| 414 | public $versionField; |
||
| 415 | |||
| 416 | /** |
||
| 417 | * READ-ONLY: A flag for whether or not instances of this class are to allow pessimistic |
||
| 418 | * locking. |
||
| 419 | * |
||
| 420 | * @var boolean $isLockable |
||
| 421 | */ |
||
| 422 | public $isLockable; |
||
| 423 | |||
| 424 | /** |
||
| 425 | * READ-ONLY: The name of the field which is used for locking a document. |
||
| 426 | * |
||
| 427 | * @var mixed $lockField |
||
| 428 | */ |
||
| 429 | public $lockField; |
||
| 430 | |||
| 431 | /** |
||
| 432 | * The ReflectionClass instance of the mapped class. |
||
| 433 | * |
||
| 434 | * @var \ReflectionClass |
||
| 435 | */ |
||
| 436 | public $reflClass; |
||
| 437 | |||
| 438 | /** |
||
| 439 | * Initializes a new ClassMetadata instance that will hold the object-document mapping |
||
| 440 | * metadata of the class with the given name. |
||
| 441 | * |
||
| 442 | * @param string $documentName The name of the document class the new instance is used for. |
||
| 443 | */ |
||
| 444 | 870 | public function __construct($documentName) |
|
| 449 | |||
| 450 | /** |
||
| 451 | * {@inheritDoc} |
||
| 452 | */ |
||
| 453 | 819 | public function getReflectionClass() |
|
| 454 | { |
||
| 455 | 819 | if ( ! $this->reflClass) { |
|
| 456 | 2 | $this->reflClass = new \ReflectionClass($this->name); |
|
| 457 | } |
||
| 458 | |||
| 459 | 819 | return $this->reflClass; |
|
| 460 | } |
||
| 461 | |||
| 462 | /** |
||
| 463 | * {@inheritDoc} |
||
| 464 | */ |
||
| 465 | 301 | public function isIdentifier($fieldName) |
|
| 469 | |||
| 470 | /** |
||
| 471 | * INTERNAL: |
||
| 472 | * Sets the mapped identifier field of this class. |
||
| 473 | * |
||
| 474 | * @param string $identifier |
||
| 475 | */ |
||
| 476 | 338 | public function setIdentifier($identifier) |
|
| 480 | |||
| 481 | /** |
||
| 482 | * {@inheritDoc} |
||
| 483 | * |
||
| 484 | * Since MongoDB only allows exactly one identifier field |
||
| 485 | * this will always return an array with only one value |
||
| 486 | */ |
||
| 487 | 26 | public function getIdentifier() |
|
| 491 | |||
| 492 | /** |
||
| 493 | * {@inheritDoc} |
||
| 494 | * |
||
| 495 | * Since MongoDB only allows exactly one identifier field |
||
| 496 | * this will always return an array with only one value |
||
| 497 | */ |
||
| 498 | 93 | public function getIdentifierFieldNames() |
|
| 502 | |||
| 503 | /** |
||
| 504 | * {@inheritDoc} |
||
| 505 | */ |
||
| 506 | 525 | public function hasField($fieldName) |
|
| 510 | |||
| 511 | /** |
||
| 512 | * Sets the inheritance type used by the class and it's subclasses. |
||
| 513 | * |
||
| 514 | * @param integer $type |
||
| 515 | */ |
||
| 516 | 349 | public function setInheritanceType($type) |
|
| 520 | |||
| 521 | /** |
||
| 522 | * Checks whether a mapped field is inherited from an entity superclass. |
||
| 523 | * |
||
| 524 | * @param string $fieldName |
||
| 525 | * |
||
| 526 | * @return boolean TRUE if the field is inherited, FALSE otherwise. |
||
| 527 | */ |
||
| 528 | 819 | public function isInheritedField($fieldName) |
|
| 532 | |||
| 533 | /** |
||
| 534 | * Registers a custom repository class for the document class. |
||
| 535 | * |
||
| 536 | * @param string $repositoryClassName The class name of the custom repository. |
||
| 537 | */ |
||
| 538 | 293 | View Code Duplication | public function setCustomRepositoryClass($repositoryClassName) |
|
|
|||
| 539 | { |
||
| 540 | 293 | if ($this->isEmbeddedDocument) { |
|
| 541 | return; |
||
| 542 | } |
||
| 543 | |||
| 544 | 293 | if ($repositoryClassName && strpos($repositoryClassName, '\\') === false && strlen($this->namespace)) { |
|
| 545 | 3 | $repositoryClassName = $this->namespace . '\\' . $repositoryClassName; |
|
| 546 | } |
||
| 547 | |||
| 548 | 293 | $this->customRepositoryClassName = $repositoryClassName; |
|
| 549 | 293 | } |
|
| 550 | |||
| 551 | /** |
||
| 552 | * Dispatches the lifecycle event of the given document by invoking all |
||
| 553 | * registered callbacks. |
||
| 554 | * |
||
| 555 | * @param string $event Lifecycle event |
||
| 556 | * @param object $document Document on which the event occurred |
||
| 557 | * @param array $arguments Arguments to pass to all callbacks |
||
| 558 | * @throws \InvalidArgumentException if document class is not this class or |
||
| 559 | * a Proxy of this class |
||
| 560 | */ |
||
| 561 | 602 | public function invokeLifecycleCallbacks($event, $document, array $arguments = null) |
|
| 562 | { |
||
| 563 | 602 | if ( ! $document instanceof $this->name) { |
|
| 564 | 1 | throw new \InvalidArgumentException(sprintf('Expected document class "%s"; found: "%s"', $this->name, get_class($document))); |
|
| 565 | } |
||
| 566 | |||
| 567 | 601 | if (empty($this->lifecycleCallbacks[$event])) { |
|
| 568 | 588 | return; |
|
| 569 | } |
||
| 570 | |||
| 571 | 184 | foreach ($this->lifecycleCallbacks[$event] as $callback) { |
|
| 572 | 184 | if ($arguments !== null) { |
|
| 573 | 183 | call_user_func_array(array($document, $callback), $arguments); |
|
| 574 | } else { |
||
| 575 | 184 | $document->$callback(); |
|
| 576 | } |
||
| 577 | } |
||
| 578 | 184 | } |
|
| 579 | |||
| 580 | /** |
||
| 581 | * Checks whether the class has callbacks registered for a lifecycle event. |
||
| 582 | * |
||
| 583 | * @param string $event Lifecycle event |
||
| 584 | * |
||
| 585 | * @return boolean |
||
| 586 | */ |
||
| 587 | public function hasLifecycleCallbacks($event) |
||
| 591 | |||
| 592 | /** |
||
| 593 | * Gets the registered lifecycle callbacks for an event. |
||
| 594 | * |
||
| 595 | * @param string $event |
||
| 596 | * @return array |
||
| 597 | */ |
||
| 598 | public function getLifecycleCallbacks($event) |
||
| 602 | |||
| 603 | /** |
||
| 604 | * Adds a lifecycle callback for documents of this class. |
||
| 605 | * |
||
| 606 | * If the callback is already registered, this is a NOOP. |
||
| 607 | * |
||
| 608 | * @param string $callback |
||
| 609 | * @param string $event |
||
| 610 | */ |
||
| 611 | 274 | public function addLifecycleCallback($callback, $event) |
|
| 619 | |||
| 620 | /** |
||
| 621 | * Sets the lifecycle callbacks for documents of this class. |
||
| 622 | * |
||
| 623 | * Any previously registered callbacks are overwritten. |
||
| 624 | * |
||
| 625 | * @param array $callbacks |
||
| 626 | */ |
||
| 627 | 337 | public function setLifecycleCallbacks(array $callbacks) |
|
| 631 | |||
| 632 | /** |
||
| 633 | * Registers a method for loading document data before field hydration. |
||
| 634 | * |
||
| 635 | * Note: A method may be registered multiple times for different fields. |
||
| 636 | * it will be invoked only once for the first field found. |
||
| 637 | * |
||
| 638 | * @param string $method Method name |
||
| 639 | * @param array|string $fields Database field name(s) |
||
| 640 | */ |
||
| 641 | 15 | public function registerAlsoLoadMethod($method, $fields) |
|
| 645 | |||
| 646 | /** |
||
| 647 | * Sets the AlsoLoad methods for documents of this class. |
||
| 648 | * |
||
| 649 | * Any previously registered methods are overwritten. |
||
| 650 | * |
||
| 651 | * @param array $methods |
||
| 652 | */ |
||
| 653 | 337 | public function setAlsoLoadMethods(array $methods) |
|
| 657 | |||
| 658 | /** |
||
| 659 | * Sets the discriminator field. |
||
| 660 | * |
||
| 661 | * The field name is the the unmapped database field. Discriminator values |
||
| 662 | * are only used to discern the hydration class and are not mapped to class |
||
| 663 | * properties. |
||
| 664 | * |
||
| 665 | * @param string $discriminatorField |
||
| 666 | * |
||
| 667 | * @throws MappingException If the discriminator field conflicts with the |
||
| 668 | * "name" attribute of a mapped field. |
||
| 669 | */ |
||
| 670 | 358 | public function setDiscriminatorField($discriminatorField) |
|
| 671 | { |
||
| 672 | 358 | if ($discriminatorField === null) { |
|
| 673 | 298 | $this->discriminatorField = null; |
|
| 674 | |||
| 675 | 298 | return; |
|
| 676 | } |
||
| 677 | |||
| 678 | // Handle array argument with name/fieldName keys for BC |
||
| 679 | 115 | if (is_array($discriminatorField)) { |
|
| 680 | if (isset($discriminatorField['name'])) { |
||
| 681 | $discriminatorField = $discriminatorField['name']; |
||
| 682 | } elseif (isset($discriminatorField['fieldName'])) { |
||
| 683 | $discriminatorField = $discriminatorField['fieldName']; |
||
| 684 | } |
||
| 685 | } |
||
| 686 | |||
| 687 | 115 | foreach ($this->fieldMappings as $fieldMapping) { |
|
| 688 | 4 | if ($discriminatorField == $fieldMapping['name']) { |
|
| 689 | 4 | throw MappingException::discriminatorFieldConflict($this->name, $discriminatorField); |
|
| 690 | } |
||
| 691 | } |
||
| 692 | |||
| 693 | 114 | $this->discriminatorField = $discriminatorField; |
|
| 694 | 114 | } |
|
| 695 | |||
| 696 | /** |
||
| 697 | * Sets the discriminator values used by this class. |
||
| 698 | * Used for JOINED and SINGLE_TABLE inheritance mapping strategies. |
||
| 699 | * |
||
| 700 | * @param array $map |
||
| 701 | * |
||
| 702 | * @throws MappingException |
||
| 703 | */ |
||
| 704 | 354 | public function setDiscriminatorMap(array $map) |
|
| 705 | { |
||
| 706 | 354 | foreach ($map as $value => $className) { |
|
| 707 | 113 | if (strpos($className, '\\') === false && strlen($this->namespace)) { |
|
| 708 | 81 | $className = $this->namespace . '\\' . $className; |
|
| 709 | } |
||
| 710 | 113 | $this->discriminatorMap[$value] = $className; |
|
| 711 | 113 | if ($this->name == $className) { |
|
| 712 | 105 | $this->discriminatorValue = $value; |
|
| 713 | } else { |
||
| 714 | 105 | if ( ! class_exists($className)) { |
|
| 715 | throw MappingException::invalidClassInDiscriminatorMap($className, $this->name); |
||
| 716 | } |
||
| 717 | 105 | if (is_subclass_of($className, $this->name)) { |
|
| 718 | 113 | $this->subClasses[] = $className; |
|
| 719 | } |
||
| 720 | } |
||
| 721 | } |
||
| 722 | 354 | } |
|
| 723 | |||
| 724 | /** |
||
| 725 | * Sets the default discriminator value to be used for this class |
||
| 726 | * Used for JOINED and SINGLE_TABLE inheritance mapping strategies if the document has no discriminator value |
||
| 727 | * |
||
| 728 | * @param string $defaultDiscriminatorValue |
||
| 729 | * |
||
| 730 | * @throws MappingException |
||
| 731 | */ |
||
| 732 | 343 | public function setDefaultDiscriminatorValue($defaultDiscriminatorValue) |
|
| 746 | |||
| 747 | /** |
||
| 748 | * Sets the discriminator value for this class. |
||
| 749 | * Used for JOINED/SINGLE_TABLE inheritance and multiple document types in a single |
||
| 750 | * collection. |
||
| 751 | * |
||
| 752 | * @param string $value |
||
| 753 | */ |
||
| 754 | public function setDiscriminatorValue($value) |
||
| 759 | |||
| 760 | /** |
||
| 761 | * Sets the slaveOkay option applied to collections for this class. |
||
| 762 | * |
||
| 763 | * @param boolean|null $slaveOkay |
||
| 764 | */ |
||
| 765 | 3 | public function setSlaveOkay($slaveOkay) |
|
| 769 | |||
| 770 | /** |
||
| 771 | * Add a index for this Document. |
||
| 772 | * |
||
| 773 | * @param array $keys Array of keys for the index. |
||
| 774 | * @param array $options Array of options for the index. |
||
| 775 | */ |
||
| 776 | 220 | public function addIndex($keys, array $options = array()) |
|
| 777 | { |
||
| 778 | 220 | $this->indexes[] = array( |
|
| 779 | 'keys' => array_map(function($value) { |
||
| 780 | 220 | if ($value == 1 || $value == -1) { |
|
| 781 | 55 | return (int) $value; |
|
| 782 | } |
||
| 783 | 212 | if (is_string($value)) { |
|
| 784 | 212 | $lower = strtolower($value); |
|
| 785 | 212 | if ($lower === 'asc') { |
|
| 786 | 205 | return 1; |
|
| 787 | 10 | } elseif ($lower === 'desc') { |
|
| 788 | 3 | return -1; |
|
| 789 | } |
||
| 790 | } |
||
| 791 | 7 | return $value; |
|
| 792 | 220 | }, $keys), |
|
| 793 | 220 | 'options' => $options |
|
| 794 | ); |
||
| 795 | 220 | } |
|
| 796 | |||
| 797 | /** |
||
| 798 | * Set whether or not queries on this document should require indexes. |
||
| 799 | * |
||
| 800 | * @param bool $requireIndexes |
||
| 801 | */ |
||
| 802 | 811 | public function setRequireIndexes($requireIndexes) |
|
| 806 | |||
| 807 | /** |
||
| 808 | * Returns the array of indexes for this Document. |
||
| 809 | * |
||
| 810 | * @return array $indexes The array of indexes. |
||
| 811 | */ |
||
| 812 | 53 | public function getIndexes() |
|
| 816 | |||
| 817 | /** |
||
| 818 | * Checks whether this document has indexes or not. |
||
| 819 | * |
||
| 820 | * @return boolean |
||
| 821 | */ |
||
| 822 | public function hasIndexes() |
||
| 826 | |||
| 827 | /** |
||
| 828 | * Sets the change tracking policy used by this class. |
||
| 829 | * |
||
| 830 | * @param integer $policy |
||
| 831 | */ |
||
| 832 | 342 | public function setChangeTrackingPolicy($policy) |
|
| 836 | |||
| 837 | /** |
||
| 838 | * Whether the change tracking policy of this class is "deferred explicit". |
||
| 839 | * |
||
| 840 | * @return boolean |
||
| 841 | */ |
||
| 842 | 62 | public function isChangeTrackingDeferredExplicit() |
|
| 846 | |||
| 847 | /** |
||
| 848 | * Whether the change tracking policy of this class is "deferred implicit". |
||
| 849 | * |
||
| 850 | * @return boolean |
||
| 851 | */ |
||
| 852 | 577 | public function isChangeTrackingDeferredImplicit() |
|
| 856 | |||
| 857 | /** |
||
| 858 | * Whether the change tracking policy of this class is "notify". |
||
| 859 | * |
||
| 860 | * @return boolean |
||
| 861 | */ |
||
| 862 | 334 | public function isChangeTrackingNotify() |
|
| 866 | |||
| 867 | /** |
||
| 868 | * Gets the ReflectionProperties of the mapped class. |
||
| 869 | * |
||
| 870 | * @return array An array of ReflectionProperty instances. |
||
| 871 | */ |
||
| 872 | 93 | public function getReflectionProperties() |
|
| 876 | |||
| 877 | /** |
||
| 878 | * Gets a ReflectionProperty for a specific field of the mapped class. |
||
| 879 | * |
||
| 880 | * @param string $name |
||
| 881 | * |
||
| 882 | * @return \ReflectionProperty |
||
| 883 | */ |
||
| 884 | public function getReflectionProperty($name) |
||
| 888 | |||
| 889 | /** |
||
| 890 | * {@inheritDoc} |
||
| 891 | */ |
||
| 892 | 816 | public function getName() |
|
| 896 | |||
| 897 | /** |
||
| 898 | * The namespace this Document class belongs to. |
||
| 899 | * |
||
| 900 | * @return string $namespace The namespace name. |
||
| 901 | */ |
||
| 902 | public function getNamespace() |
||
| 906 | |||
| 907 | /** |
||
| 908 | * Returns the database this Document is mapped to. |
||
| 909 | * |
||
| 910 | * @return string $db The database name. |
||
| 911 | */ |
||
| 912 | 755 | public function getDatabase() |
|
| 916 | |||
| 917 | /** |
||
| 918 | * Set the database this Document is mapped to. |
||
| 919 | * |
||
| 920 | * @param string $db The database name |
||
| 921 | */ |
||
| 922 | 93 | public function setDatabase($db) |
|
| 926 | |||
| 927 | /** |
||
| 928 | * Get the collection this Document is mapped to. |
||
| 929 | * |
||
| 930 | * @return string $collection The collection name. |
||
| 931 | */ |
||
| 932 | 759 | public function getCollection() |
|
| 936 | |||
| 937 | /** |
||
| 938 | * Sets the collection this Document is mapped to. |
||
| 939 | * |
||
| 940 | * @param array|string $name |
||
| 941 | * |
||
| 942 | * @throws \InvalidArgumentException |
||
| 943 | */ |
||
| 944 | 849 | public function setCollection($name) |
|
| 945 | { |
||
| 946 | 849 | if (is_array($name)) { |
|
| 947 | if ( ! isset($name['name'])) { |
||
| 948 | throw new \InvalidArgumentException('A name key is required when passing an array to setCollection()'); |
||
| 949 | } |
||
| 950 | $this->collectionCapped = isset($name['capped']) ? $name['capped'] : false; |
||
| 951 | $this->collectionSize = isset($name['size']) ? $name['size'] : 0; |
||
| 952 | $this->collectionMax = isset($name['max']) ? $name['max'] : 0; |
||
| 953 | $this->collection = $name['name']; |
||
| 954 | } else { |
||
| 955 | 849 | $this->collection = $name; |
|
| 956 | } |
||
| 957 | 849 | } |
|
| 958 | |||
| 959 | /** |
||
| 960 | * Get whether or not the documents collection is capped. |
||
| 961 | * |
||
| 962 | * @return boolean |
||
| 963 | */ |
||
| 964 | 4 | public function getCollectionCapped() |
|
| 968 | |||
| 969 | /** |
||
| 970 | * Set whether or not the documents collection is capped. |
||
| 971 | * |
||
| 972 | * @param boolean $bool |
||
| 973 | */ |
||
| 974 | 1 | public function setCollectionCapped($bool) |
|
| 978 | |||
| 979 | /** |
||
| 980 | * Get the collection size |
||
| 981 | * |
||
| 982 | * @return integer |
||
| 983 | */ |
||
| 984 | 4 | public function getCollectionSize() |
|
| 988 | |||
| 989 | /** |
||
| 990 | * Set the collection size. |
||
| 991 | * |
||
| 992 | * @param integer $size |
||
| 993 | */ |
||
| 994 | 1 | public function setCollectionSize($size) |
|
| 998 | |||
| 999 | /** |
||
| 1000 | * Get the collection max. |
||
| 1001 | * |
||
| 1002 | * @return integer |
||
| 1003 | */ |
||
| 1004 | 4 | public function getCollectionMax() |
|
| 1008 | |||
| 1009 | /** |
||
| 1010 | * Set the collection max. |
||
| 1011 | * |
||
| 1012 | * @param integer $max |
||
| 1013 | */ |
||
| 1014 | 1 | public function setCollectionMax($max) |
|
| 1018 | |||
| 1019 | /** |
||
| 1020 | * Returns TRUE if this Document is mapped to a collection FALSE otherwise. |
||
| 1021 | * |
||
| 1022 | * @return boolean |
||
| 1023 | */ |
||
| 1024 | public function isMappedToCollection() |
||
| 1028 | |||
| 1029 | /** |
||
| 1030 | * Returns TRUE if this Document is a file to be stored on the MongoGridFS FALSE otherwise. |
||
| 1031 | * |
||
| 1032 | * @return boolean |
||
| 1033 | */ |
||
| 1034 | 708 | public function isFile() |
|
| 1038 | |||
| 1039 | /** |
||
| 1040 | * Returns the file field name. |
||
| 1041 | * |
||
| 1042 | * @return string $file The file field name. |
||
| 1043 | */ |
||
| 1044 | 337 | public function getFile() |
|
| 1048 | |||
| 1049 | /** |
||
| 1050 | * Set the field name that stores the grid file. |
||
| 1051 | * |
||
| 1052 | * @param string $file |
||
| 1053 | */ |
||
| 1054 | 338 | public function setFile($file) |
|
| 1058 | |||
| 1059 | /** |
||
| 1060 | * Returns the distance field name. |
||
| 1061 | * |
||
| 1062 | * @return string $distance The distance field name. |
||
| 1063 | */ |
||
| 1064 | public function getDistance() |
||
| 1068 | |||
| 1069 | /** |
||
| 1070 | * Set the field name that stores the distance. |
||
| 1071 | * |
||
| 1072 | * @param string $distance |
||
| 1073 | */ |
||
| 1074 | 1 | public function setDistance($distance) |
|
| 1078 | |||
| 1079 | /** |
||
| 1080 | * Map a field. |
||
| 1081 | * |
||
| 1082 | * @param array $mapping The mapping information. |
||
| 1083 | * |
||
| 1084 | * @return array |
||
| 1085 | * |
||
| 1086 | * @throws MappingException |
||
| 1087 | */ |
||
| 1088 | 856 | public function mapField(array $mapping) |
|
| 1272 | |||
| 1273 | /** |
||
| 1274 | * Validates the storage strategy of a mapping for consistency |
||
| 1275 | * @param array $mapping |
||
| 1276 | * @throws \Doctrine\ODM\MongoDB\Mapping\MappingException |
||
| 1277 | */ |
||
| 1278 | 846 | private function applyStorageStrategy(array &$mapping) |
|
| 1322 | |||
| 1323 | /** |
||
| 1324 | * Map a MongoGridFSFile. |
||
| 1325 | * |
||
| 1326 | * @param array $mapping The mapping information. |
||
| 1327 | */ |
||
| 1328 | public function mapFile(array $mapping) |
||
| 1334 | |||
| 1335 | /** |
||
| 1336 | * Map a single embedded document. |
||
| 1337 | * |
||
| 1338 | * @param array $mapping The mapping information. |
||
| 1339 | */ |
||
| 1340 | 6 | public function mapOneEmbedded(array $mapping) |
|
| 1346 | |||
| 1347 | /** |
||
| 1348 | * Map a collection of embedded documents. |
||
| 1349 | * |
||
| 1350 | * @param array $mapping The mapping information. |
||
| 1351 | */ |
||
| 1352 | 3 | public function mapManyEmbedded(array $mapping) |
|
| 1358 | |||
| 1359 | /** |
||
| 1360 | * Map a single document reference. |
||
| 1361 | * |
||
| 1362 | * @param array $mapping The mapping information. |
||
| 1363 | */ |
||
| 1364 | 8 | public function mapOneReference(array $mapping) |
|
| 1370 | |||
| 1371 | /** |
||
| 1372 | * Map a collection of document references. |
||
| 1373 | * |
||
| 1374 | * @param array $mapping The mapping information. |
||
| 1375 | */ |
||
| 1376 | 8 | public function mapManyReference(array $mapping) |
|
| 1382 | |||
| 1383 | /** |
||
| 1384 | * INTERNAL: |
||
| 1385 | * Adds a field mapping without completing/validating it. |
||
| 1386 | * This is mainly used to add inherited field mappings to derived classes. |
||
| 1387 | * |
||
| 1388 | * @param array $fieldMapping |
||
| 1389 | */ |
||
| 1390 | 115 | public function addInheritedFieldMapping(array $fieldMapping) |
|
| 1398 | |||
| 1399 | /** |
||
| 1400 | * INTERNAL: |
||
| 1401 | * Adds an association mapping without completing/validating it. |
||
| 1402 | * This is mainly used to add inherited association mappings to derived classes. |
||
| 1403 | * |
||
| 1404 | * @param array $mapping |
||
| 1405 | * |
||
| 1406 | * @return void |
||
| 1407 | * |
||
| 1408 | * @throws MappingException |
||
| 1409 | */ |
||
| 1410 | 77 | public function addInheritedAssociationMapping(array $mapping/*, $owningClassName = null*/) |
|
| 1414 | |||
| 1415 | /** |
||
| 1416 | * Checks whether the class has a mapped association with the given field name. |
||
| 1417 | * |
||
| 1418 | * @param string $fieldName |
||
| 1419 | * @return boolean |
||
| 1420 | */ |
||
| 1421 | 7 | public function hasReference($fieldName) |
|
| 1425 | |||
| 1426 | /** |
||
| 1427 | * Checks whether the class has a mapped embed with the given field name. |
||
| 1428 | * |
||
| 1429 | * @param string $fieldName |
||
| 1430 | * @return boolean |
||
| 1431 | */ |
||
| 1432 | 5 | public function hasEmbed($fieldName) |
|
| 1436 | |||
| 1437 | /** |
||
| 1438 | * {@inheritDoc} |
||
| 1439 | * |
||
| 1440 | * Checks whether the class has a mapped association (embed or reference) with the given field name. |
||
| 1441 | */ |
||
| 1442 | 7 | public function hasAssociation($fieldName) |
|
| 1446 | |||
| 1447 | /** |
||
| 1448 | * {@inheritDoc} |
||
| 1449 | * |
||
| 1450 | * Checks whether the class has a mapped reference or embed for the specified field and |
||
| 1451 | * is a single valued association. |
||
| 1452 | */ |
||
| 1453 | public function isSingleValuedAssociation($fieldName) |
||
| 1457 | |||
| 1458 | /** |
||
| 1459 | * {@inheritDoc} |
||
| 1460 | * |
||
| 1461 | * Checks whether the class has a mapped reference or embed for the specified field and |
||
| 1462 | * is a collection valued association. |
||
| 1463 | */ |
||
| 1464 | public function isCollectionValuedAssociation($fieldName) |
||
| 1468 | |||
| 1469 | /** |
||
| 1470 | * Checks whether the class has a mapped association for the specified field |
||
| 1471 | * and if yes, checks whether it is a single-valued association (to-one). |
||
| 1472 | * |
||
| 1473 | * @param string $fieldName |
||
| 1474 | * @return boolean TRUE if the association exists and is single-valued, FALSE otherwise. |
||
| 1475 | */ |
||
| 1476 | public function isSingleValuedReference($fieldName) |
||
| 1481 | |||
| 1482 | /** |
||
| 1483 | * Checks whether the class has a mapped association for the specified field |
||
| 1484 | * and if yes, checks whether it is a collection-valued association (to-many). |
||
| 1485 | * |
||
| 1486 | * @param string $fieldName |
||
| 1487 | * @return boolean TRUE if the association exists and is collection-valued, FALSE otherwise. |
||
| 1488 | */ |
||
| 1489 | public function isCollectionValuedReference($fieldName) |
||
| 1494 | |||
| 1495 | /** |
||
| 1496 | * Checks whether the class has a mapped embedded document for the specified field |
||
| 1497 | * and if yes, checks whether it is a single-valued association (to-one). |
||
| 1498 | * |
||
| 1499 | * @param string $fieldName |
||
| 1500 | * @return boolean TRUE if the association exists and is single-valued, FALSE otherwise. |
||
| 1501 | */ |
||
| 1502 | public function isSingleValuedEmbed($fieldName) |
||
| 1507 | |||
| 1508 | /** |
||
| 1509 | * Checks whether the class has a mapped embedded document for the specified field |
||
| 1510 | * and if yes, checks whether it is a collection-valued association (to-many). |
||
| 1511 | * |
||
| 1512 | * @param string $fieldName |
||
| 1513 | * @return boolean TRUE if the association exists and is collection-valued, FALSE otherwise. |
||
| 1514 | */ |
||
| 1515 | public function isCollectionValuedEmbed($fieldName) |
||
| 1520 | |||
| 1521 | /** |
||
| 1522 | * Sets the ID generator used to generate IDs for instances of this class. |
||
| 1523 | * |
||
| 1524 | * @param \Doctrine\ODM\MongoDB\Id\AbstractIdGenerator $generator |
||
| 1525 | */ |
||
| 1526 | 759 | public function setIdGenerator($generator) |
|
| 1530 | |||
| 1531 | /** |
||
| 1532 | * Casts the identifier to its portable PHP type. |
||
| 1533 | * |
||
| 1534 | * @param mixed $id |
||
| 1535 | * @return mixed $id |
||
| 1536 | */ |
||
| 1537 | 594 | public function getPHPIdentifierValue($id) |
|
| 1542 | |||
| 1543 | /** |
||
| 1544 | * Casts the identifier to its database type. |
||
| 1545 | * |
||
| 1546 | * @param mixed $id |
||
| 1547 | * @return mixed $id |
||
| 1548 | */ |
||
| 1549 | 656 | public function getDatabaseIdentifierValue($id) |
|
| 1554 | |||
| 1555 | /** |
||
| 1556 | * Sets the document identifier of a document. |
||
| 1557 | * |
||
| 1558 | * The value will be converted to a PHP type before being set. |
||
| 1559 | * |
||
| 1560 | * @param object $document |
||
| 1561 | * @param mixed $id |
||
| 1562 | */ |
||
| 1563 | 527 | public function setIdentifierValue($document, $id) |
|
| 1568 | |||
| 1569 | /** |
||
| 1570 | * Gets the document identifier as a PHP type. |
||
| 1571 | * |
||
| 1572 | * @param object $document |
||
| 1573 | * @return mixed $id |
||
| 1574 | */ |
||
| 1575 | 607 | public function getIdentifierValue($document) |
|
| 1579 | |||
| 1580 | /** |
||
| 1581 | * {@inheritDoc} |
||
| 1582 | * |
||
| 1583 | * Since MongoDB only allows exactly one identifier field this is a proxy |
||
| 1584 | * to {@see getIdentifierValue()} and returns an array with the identifier |
||
| 1585 | * field as a key. |
||
| 1586 | */ |
||
| 1587 | public function getIdentifierValues($object) |
||
| 1591 | |||
| 1592 | /** |
||
| 1593 | * Get the document identifier object as a database type. |
||
| 1594 | * |
||
| 1595 | * @param object $document |
||
| 1596 | * |
||
| 1597 | * @return \MongoId $id The MongoID object. |
||
| 1598 | */ |
||
| 1599 | 32 | public function getIdentifierObject($document) |
|
| 1603 | |||
| 1604 | /** |
||
| 1605 | * Sets the specified field to the specified value on the given document. |
||
| 1606 | * |
||
| 1607 | * @param object $document |
||
| 1608 | * @param string $field |
||
| 1609 | * @param mixed $value |
||
| 1610 | */ |
||
| 1611 | 7 | public function setFieldValue($document, $field, $value) |
|
| 1621 | |||
| 1622 | /** |
||
| 1623 | * Gets the specified field's value off the given document. |
||
| 1624 | * |
||
| 1625 | * @param object $document |
||
| 1626 | * @param string $field |
||
| 1627 | * |
||
| 1628 | * @return mixed |
||
| 1629 | */ |
||
| 1630 | 26 | public function getFieldValue($document, $field) |
|
| 1638 | |||
| 1639 | /** |
||
| 1640 | * Gets the mapping of a field. |
||
| 1641 | * |
||
| 1642 | * @param string $fieldName The field name. |
||
| 1643 | * |
||
| 1644 | * @return array The field mapping. |
||
| 1645 | * |
||
| 1646 | * @throws MappingException if the $fieldName is not found in the fieldMappings array |
||
| 1647 | * |
||
| 1648 | * @throws MappingException |
||
| 1649 | */ |
||
| 1650 | 90 | public function getFieldMapping($fieldName) |
|
| 1657 | |||
| 1658 | /** |
||
| 1659 | * Gets mappings of fields holding embedded document(s). |
||
| 1660 | * |
||
| 1661 | * @return array of field mappings |
||
| 1662 | */ |
||
| 1663 | 569 | public function getEmbeddedFieldsMappings() |
|
| 1670 | |||
| 1671 | /** |
||
| 1672 | * Check if the field is not null. |
||
| 1673 | * |
||
| 1674 | * @param string $fieldName The field name |
||
| 1675 | * |
||
| 1676 | * @return boolean TRUE if the field is not null, FALSE otherwise. |
||
| 1677 | */ |
||
| 1678 | 1 | public function isNullable($fieldName) |
|
| 1686 | |||
| 1687 | /** |
||
| 1688 | * Checks whether the document has a discriminator field and value configured. |
||
| 1689 | * |
||
| 1690 | * @return boolean |
||
| 1691 | */ |
||
| 1692 | 488 | public function hasDiscriminator() |
|
| 1696 | |||
| 1697 | /** |
||
| 1698 | * Sets the type of Id generator to use for the mapped class. |
||
| 1699 | * |
||
| 1700 | * @param string $generatorType Generator type. |
||
| 1701 | */ |
||
| 1702 | 343 | public function setIdGeneratorType($generatorType) |
|
| 1706 | |||
| 1707 | /** |
||
| 1708 | * Sets the Id generator options. |
||
| 1709 | * |
||
| 1710 | * @param array $generatorOptions Generator options. |
||
| 1711 | */ |
||
| 1712 | public function setIdGeneratorOptions($generatorOptions) |
||
| 1716 | |||
| 1717 | /** |
||
| 1718 | * @return boolean |
||
| 1719 | */ |
||
| 1720 | 575 | public function isInheritanceTypeNone() |
|
| 1724 | |||
| 1725 | /** |
||
| 1726 | * Checks whether the mapped class uses the SINGLE_COLLECTION inheritance mapping strategy. |
||
| 1727 | * |
||
| 1728 | * @return boolean |
||
| 1729 | */ |
||
| 1730 | 337 | public function isInheritanceTypeSingleCollection() |
|
| 1734 | |||
| 1735 | /** |
||
| 1736 | * Checks whether the mapped class uses the COLLECTION_PER_CLASS inheritance mapping strategy. |
||
| 1737 | * |
||
| 1738 | * @return boolean |
||
| 1739 | */ |
||
| 1740 | public function isInheritanceTypeCollectionPerClass() |
||
| 1744 | |||
| 1745 | /** |
||
| 1746 | * Sets the mapped subclasses of this class. |
||
| 1747 | * |
||
| 1748 | * @param string[] $subclasses The names of all mapped subclasses. |
||
| 1749 | */ |
||
| 1750 | 2 | View Code Duplication | public function setSubclasses(array $subclasses) |
| 1760 | |||
| 1761 | /** |
||
| 1762 | * Sets the parent class names. |
||
| 1763 | * Assumes that the class names in the passed array are in the order: |
||
| 1764 | * directParent -> directParentParent -> directParentParentParent ... -> root. |
||
| 1765 | * |
||
| 1766 | * @param string[] $classNames |
||
| 1767 | */ |
||
| 1768 | 814 | public function setParentClasses(array $classNames) |
|
| 1776 | |||
| 1777 | /** |
||
| 1778 | * Checks whether the class will generate a new \MongoId instance for us. |
||
| 1779 | * |
||
| 1780 | * @return boolean TRUE if the class uses the AUTO generator, FALSE otherwise. |
||
| 1781 | */ |
||
| 1782 | public function isIdGeneratorAuto() |
||
| 1786 | |||
| 1787 | /** |
||
| 1788 | * Checks whether the class will use a collection to generate incremented identifiers. |
||
| 1789 | * |
||
| 1790 | * @return boolean TRUE if the class uses the INCREMENT generator, FALSE otherwise. |
||
| 1791 | */ |
||
| 1792 | public function isIdGeneratorIncrement() |
||
| 1796 | |||
| 1797 | /** |
||
| 1798 | * Checks whether the class will generate a uuid id. |
||
| 1799 | * |
||
| 1800 | * @return boolean TRUE if the class uses the UUID generator, FALSE otherwise. |
||
| 1801 | */ |
||
| 1802 | public function isIdGeneratorUuid() |
||
| 1806 | |||
| 1807 | /** |
||
| 1808 | * Checks whether the class uses no id generator. |
||
| 1809 | * |
||
| 1810 | * @return boolean TRUE if the class does not use any id generator, FALSE otherwise. |
||
| 1811 | */ |
||
| 1812 | public function isIdGeneratorNone() |
||
| 1816 | |||
| 1817 | /** |
||
| 1818 | * Sets the version field mapping used for versioning. Sets the default |
||
| 1819 | * value to use depending on the column type. |
||
| 1820 | * |
||
| 1821 | * @param array $mapping The version field mapping array |
||
| 1822 | * |
||
| 1823 | * @throws LockException |
||
| 1824 | */ |
||
| 1825 | 93 | public function setVersionMapping(array &$mapping) |
|
| 1834 | |||
| 1835 | /** |
||
| 1836 | * Sets whether this class is to be versioned for optimistic locking. |
||
| 1837 | * |
||
| 1838 | * @param boolean $bool |
||
| 1839 | */ |
||
| 1840 | 337 | public function setVersioned($bool) |
|
| 1844 | |||
| 1845 | /** |
||
| 1846 | * Sets the name of the field that is to be used for versioning if this class is |
||
| 1847 | * versioned for optimistic locking. |
||
| 1848 | * |
||
| 1849 | * @param string $versionField |
||
| 1850 | */ |
||
| 1851 | 337 | public function setVersionField($versionField) |
|
| 1855 | |||
| 1856 | /** |
||
| 1857 | * Sets the version field mapping used for versioning. Sets the default |
||
| 1858 | * value to use depending on the column type. |
||
| 1859 | * |
||
| 1860 | * @param array $mapping The version field mapping array |
||
| 1861 | * |
||
| 1862 | * @throws \Doctrine\ODM\MongoDB\LockException |
||
| 1863 | */ |
||
| 1864 | 26 | public function setLockMapping(array &$mapping) |
|
| 1873 | |||
| 1874 | /** |
||
| 1875 | * Sets whether this class is to allow pessimistic locking. |
||
| 1876 | * |
||
| 1877 | * @param boolean $bool |
||
| 1878 | */ |
||
| 1879 | public function setLockable($bool) |
||
| 1883 | |||
| 1884 | /** |
||
| 1885 | * Sets the name of the field that is to be used for storing whether a document |
||
| 1886 | * is currently locked or not. |
||
| 1887 | * |
||
| 1888 | * @param string $lockField |
||
| 1889 | */ |
||
| 1890 | public function setLockField($lockField) |
||
| 1894 | |||
| 1895 | /** |
||
| 1896 | * {@inheritDoc} |
||
| 1897 | */ |
||
| 1898 | public function getFieldNames() |
||
| 1902 | |||
| 1903 | /** |
||
| 1904 | * {@inheritDoc} |
||
| 1905 | */ |
||
| 1906 | public function getAssociationNames() |
||
| 1910 | |||
| 1911 | /** |
||
| 1912 | * {@inheritDoc} |
||
| 1913 | */ |
||
| 1914 | 22 | public function getTypeOfField($fieldName) |
|
| 1919 | |||
| 1920 | /** |
||
| 1921 | * {@inheritDoc} |
||
| 1922 | */ |
||
| 1923 | 6 | public function getAssociationTargetClass($assocName) |
|
| 1931 | |||
| 1932 | /** |
||
| 1933 | * {@inheritDoc} |
||
| 1934 | */ |
||
| 1935 | public function isAssociationInverseSide($fieldName) |
||
| 1939 | |||
| 1940 | /** |
||
| 1941 | * {@inheritDoc} |
||
| 1942 | */ |
||
| 1943 | public function getAssociationMappedByTargetField($fieldName) |
||
| 1947 | } |
||
| 1948 |
Loading history...
Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation.
You can also find more detailed suggestions in the “Code” section of your repository.