PHP ClassMetadata::isInheritanceTypeNone方法代码示例

 /**
  * INTERNAL:
  * Computes the changeset of an individual document, independently of the
  * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit().
  *
  * The passed document must be a managed document. If the document already has a change set
  * because this method is invoked during a commit cycle then the change sets are added.
  * whereby changes detected in this method prevail.
  *
  * @ignore
  * @param ClassMetadata $class The class descriptor of the document.
  * @param object $document The document for which to (re)calculate the change set.
  * @throws InvalidArgumentException If the passed document is not MANAGED.
  */
 public function recomputeSingleDocumentChangeSet($class, $document)
 {
     $oid = spl_object_hash($document);
     if (!isset($this->documentStates[$oid]) || $this->documentStates[$oid] != self::STATE_MANAGED) {
         throw new \InvalidArgumentException('Document must be managed.');
     }
     if (!$class->isInheritanceTypeNone()) {
         $class = $this->dm->getClassMetadata(get_class($document));
     }
     $actualData = $this->getDocumentActualData($document);
     $isChangeTrackingNotify = $class->isChangeTrackingNotify();
     $originalData = isset($this->originalDocumentData[$oid]) ? $this->originalDocumentData[$oid] : array();
     $changeSet = array();
     foreach ($actualData as $propName => $actualValue) {
         $orgValue = isset($originalData[$propName]) ? $originalData[$propName] : null;
         if (isset($class->fieldMappings[$propName]['embedded']) && $class->fieldMappings[$propName]['type'] === 'one' && $orgValue !== $actualValue) {
             if ($orgValue !== null) {
                 $this->scheduleOrphanRemoval($orgValue);
             }
             $changeSet[$propName] = array($orgValue, $actualValue);
         } else {
             if (isset($class->fieldMappings[$propName]['reference']) && $class->fieldMappings[$propName]['type'] === 'one' && $orgValue !== $actualValue) {
                 $changeSet[$propName] = array($orgValue, $actualValue);
             } else {
                 if ($isChangeTrackingNotify) {
                     continue;
                 } else {
                     if (isset($class->fieldMappings[$propName]['type']) && $class->fieldMappings[$propName]['type'] === 'many') {
                         if ($orgValue !== $actualValue) {
                             $changeSet[$propName] = array($orgValue, $actualValue);
                             if ($orgValue instanceof PersistentCollection) {
                                 $this->collectionDeletions[] = $orgValue;
                                 $this->collectionUpdates[] = $actualValue;
                                 $this->visitedCollections[] = $actualValue;
                             }
                         }
                     } else {
                         if (is_object($orgValue) && $orgValue !== $actualValue) {
                             $changeSet[$propName] = array($orgValue, $actualValue);
                         } else {
                             if ($orgValue != $actualValue || $orgValue === null ^ $actualValue === null) {
                                 $changeSet[$propName] = array($orgValue, $actualValue);
                             }
                         }
                     }
                 }
             }
         }
     }
     if ($changeSet) {
         if (isset($this->documentChangeSets[$oid])) {
             $this->documentChangeSets[$oid] = $changeSet + $this->documentChangeSets[$oid];
         }
         $this->originalDocumentData[$oid] = $actualData;
     }
 }

 /**
  * INTERNAL:
  * Computes the changeset of an individual document, independently of the
  * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit().
  *
  * The passed document must be a managed document. If the document already has a change set
  * because this method is invoked during a commit cycle then the change sets are added.
  * whereby changes detected in this method prevail.
  *
  * @ignore
  * @param ClassMetadata $class The class descriptor of the document.
  * @param object $document The document for which to (re)calculate the change set.
  * @throws \InvalidArgumentException If the passed document is not MANAGED.
  */
 public function recomputeSingleDocumentChangeSet(ClassMetadata $class, $document)
 {
     // Ignore uninitialized proxy objects
     if ($document instanceof Proxy && !$document->__isInitialized__) {
         return;
     }
     $oid = spl_object_hash($document);
     if (!isset($this->documentStates[$oid]) || $this->documentStates[$oid] != self::STATE_MANAGED) {
         throw new \InvalidArgumentException('Document must be managed.');
     }
     if (!$class->isInheritanceTypeNone()) {
         $class = $this->dm->getClassMetadata(get_class($document));
     }
     $this->computeOrRecomputeChangeSet($class, $document, true);
 }

 /**
  * INTERNAL:
  * Computes the changeset of an individual document, independently of the
  * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit().
  * 
  * The passed document must be a managed document. If the document already has a change set
  * because this method is invoked during a commit cycle then the change sets are added.
  * whereby changes detected in this method prevail.
  * 
  * @ignore
  * @param ClassMetadata $class The class descriptor of the document.
  * @param object $document The document for which to (re)calculate the change set.
  * @throws InvalidArgumentException If the passed document is not MANAGED.
  */
 public function recomputeSingleDocumentChangeSet($class, $document)
 {
     $oid = spl_object_hash($document);
     if (!isset($this->_documentStates[$oid]) || $this->_documentStates[$oid] != self::STATE_MANAGED) {
         throw new \InvalidArgumentException('Document must be managed.');
     }
     if (!$class->isInheritanceTypeNone()) {
         $class = $this->_dm->getClassMetadata(get_class($document));
     }
     $actualData = array();
     foreach ($class->reflFields as $name => $refProp) {
         if (!$class->isIdentifier($name)) {
             $actualData[$name] = $refProp->getValue($document);
         }
     }
     $originalData = $this->_originalDocumentData[$oid];
     $changeSet = array();
     foreach ($actualData as $propName => $actualValue) {
         $orgValue = isset($originalData[$propName]) ? $originalData[$propName] : null;
         if (is_object($orgValue) && $orgValue !== $actualValue) {
             $changeSet[$propName] = array($orgValue, $actualValue);
         } elseif ($orgValue != $actualValue || $orgValue === null ^ $actualValue === null) {
             $changeSet[$propName] = array($orgValue, $actualValue);
         }
     }
     if ($changeSet) {
         if (isset($this->_documentChangeSets[$oid])) {
             $this->_documentChangeSets[$oid] = $changeSet + $this->_documentChangeSets[$oid];
         }
         $this->_originalDocumentData[$oid] = $actualData;
     }
 }

 /**
  * Computes the changes that happened to a single document.
  *
  * Modifies/populates the following properties:
  *
  * {@link _originalDocumentData}
  * If the document is NEW or MANAGED but not yet fully persisted (only has an id)
  * then it was not fetched from the database and therefore we have no original
  * document data yet. All of the current document data is stored as the original document data.
  *
  * {@link _documentChangeSets}
  * The changes detected on all properties of the document are stored there.
  * A change is a tuple array where the first entry is the old value and the second
  * entry is the new value of the property. Changesets are used by persisters
  * to INSERT/UPDATE the persistent document state.
  *
  * {@link _documentUpdates}
  * If the document is already fully MANAGED (has been fetched from the database before)
  * and any changes to its properties are detected, then a reference to the document is stored
  * there to mark it for an update.
  *
  * @param ClassMetadata $class The class descriptor of the document.
  * @param object $document The document for which to compute the changes.
  */
 public function computeChangeSet(Mapping\ClassMetadata $class, $document)
 {
     if (!$class->isInheritanceTypeNone()) {
         $class = $this->_dm->getClassMetadata(get_class($document));
     }
     $oid = spl_object_hash($document);
     $actualData = array();
     foreach ($class->reflFields as $name => $refProp) {
         if (!$class->isIdentifier($name)) {
             $actualData[$name] = $refProp->getValue($document);
         }
         if ($class->isCollectionValuedReference($name) && $actualData[$name] !== null && !$actualData[$name] instanceof PersistentCollection) {
             // If $actualData[$name] is not a Collection then use an ArrayCollection.
             if (!$actualData[$name] instanceof Collection) {
                 $actualData[$name] = new ArrayCollection($actualData[$name]);
             }
             $mapping = $class->fieldMappings[$name];
             // Inject PersistentCollection
             $coll = new PersistentCollection($this->_dm, $this->_dm->getClassMetadata($mapping['targetDocument']), $actualData[$name]);
             $coll->setOwner($document, $mapping);
             $coll->setDirty(!$coll->isEmpty());
             $class->reflFields[$name]->setValue($document, $coll);
             $actualData[$name] = $coll;
         }
     }
     if (!isset($this->_originalDocumentData[$oid])) {
         // Document is either NEW or MANAGED but not yet fully persisted (only has an id).
         // These result in an INSERT.
         $this->_originalDocumentData[$oid] = $actualData;
         $this->_documentChangeSets[$oid] = array_map(function ($e) {
             return array(null, $e);
         }, $actualData);
     } else {
         // Document is "fully" MANAGED: it was already fully persisted before
         // and we have a copy of the original data
         $originalData = $this->_originalDocumentData[$oid];
         $changeSet = array();
         $documentIsDirty = false;
         foreach ($actualData as $propName => $actualValue) {
             $orgValue = isset($originalData[$propName]) ? $originalData[$propName] : null;
             if (is_object($orgValue)) {
                 if ($orgValue instanceof PersistentCollection) {
                     $orgValue = $orgValue->getSnapshot();
                 }
                 if ($actualValue instanceof PersistentCollection) {
                     $actualValue = $actualValue->toArray();
                 }
                 if ($orgValue !== $actualValue) {
                     $changeSet[$propName] = array($orgValue, $actualValue);
                 }
             } elseif ($orgValue != $actualValue || $orgValue === null ^ $actualValue === null) {
                 $changeSet[$propName] = array($orgValue, $actualValue);
             }
             if (isset($changeSet[$propName])) {
                 if (isset($class->fieldMappings[$propName]['reference'])) {
                     $mapping = $class->fieldMappings[$propName];
                     if ($mapping['type'] === 'one') {
                         $documentIsDirty = true;
                         if ($actualValue === null) {
                             $this->scheduleOrphanRemoval($orgValue);
                         }
                     }
                 } else {
                     $documentIsDirty = true;
                 }
             }
         }
         if ($changeSet) {
             $this->_documentChangeSets[$oid] = $changeSet;
             $this->_originalDocumentData[$oid] = $actualData;
             if ($documentIsDirty) {
                 $this->_documentUpdates[$oid] = $document;
             }
         }
     }
     // Look for changes in references of the document
//.........这里部分代码省略.........

 /**
  * INTERNAL:
  * Computes the changeset of an individual document, independently of the
  * computeChangeSets() routine that is used at the beginning of a UnitOfWork#commit().
  * 
  * The passed document must be a managed document. If the document already has a change set
  * because this method is invoked during a commit cycle then the change sets are added.
  * whereby changes detected in this method prevail.
  * 
  * @ignore
  * @param ClassMetadata $class The class descriptor of the document.
  * @param object $document The document for which to (re)calculate the change set.
  * @throws InvalidArgumentException If the passed document is not MANAGED.
  */
 public function recomputeSingleDocumentChangeSet($class, $document)
 {
     $oid = spl_object_hash($document);
     if (!isset($this->documentStates[$oid]) || $this->documentStates[$oid] != self::STATE_MANAGED) {
         throw new \InvalidArgumentException('Document must be managed.');
     }
     if (!$class->isInheritanceTypeNone()) {
         $class = $this->dm->getClassMetadata(get_class($document));
     }
     $actualData = array();
     foreach ($class->reflFields as $name => $refProp) {
         if (!$class->isIdentifier($name)) {
             $actualData[$name] = $refProp->getValue($document);
         }
     }
     $originalData = $this->originalDocumentData[$oid];
     $changeSet = array();
     foreach ($actualData as $propName => $actualValue) {
         $orgValue = isset($originalData[$propName]) ? $originalData[$propName] : null;
         if ($orgValue instanceof PersistentCollection) {
             $orgValue = $orgValue->getSnapshot();
         }
         if ($actualValue instanceof PersistentCollection) {
             $actualValue = $actualValue->toArray();
         }
         if (isset($class->fieldMappings[$propName]['embedded']) && $class->fieldMappings[$propName]['type'] === 'one' || isset($class->fieldMappings[$propName]['reference']) && $class->fieldMappings[$propName]['type'] === 'one') {
             if ($orgValue !== $actualValue) {
                 $changeSet[$propName] = array($orgValue, $actualValue);
             }
         } else {
             if (isset($class->fieldMappings[$propName]['type']) && $class->fieldMappings[$propName]['type'] === 'many') {
                 $changeSet[$propName] = array($orgValue, $actualValue);
             } else {
                 if (is_object($orgValue) && $orgValue !== $actualValue) {
                     $changeSet[$propName] = array($orgValue, $actualValue);
                 } else {
                     if ($orgValue != $actualValue || $orgValue === null ^ $actualValue === null) {
                         $changeSet[$propName] = array($orgValue, $actualValue);
                     }
                 }
             }
         }
     }
     if ($changeSet) {
         if (isset($this->documentChangeSets[$oid])) {
             $this->documentChangeSets[$oid] = $changeSet + $this->documentChangeSets[$oid];
         }
         $this->originalDocumentData[$oid] = $actualData;
     }
 }

 /**
  * Computes the changes that happened to a single document.
  *
  * Modifies/populates the following properties:
  *
  * {@link _originalDocumentData}
  * If the document is NEW or MANAGED but not yet fully persisted (only has an id)
  * then it was not fetched from the database and therefore we have no original
  * document data yet. All of the current document data is stored as the original document data.
  *
  * {@link _documentChangeSets}
  * The changes detected on all properties of the document are stored there.
  * A change is a tuple array where the first entry is the old value and the second
  * entry is the new value of the property. Changesets are used by persisters
  * to INSERT/UPDATE the persistent document state.
  *
  * {@link _documentUpdates}
  * If the document is already fully MANAGED (has been fetched from the database before)
  * and any changes to its properties are detected, then a reference to the document is stored
  * there to mark it for an update.
  *
  * @param object $parentDocument The top most parent document of the document we are computing.
  * @param ClassMetadata $class The class descriptor of the document.
  * @param object $document The document for which to compute the changes.
  */
 public function computeChangeSet($parentDocument, Mapping\ClassMetadata $class, $document)
 {
     if (!$class->isInheritanceTypeNone()) {
         $class = $this->dm->getClassMetadata(get_class($document));
     }
     $oid = spl_object_hash($document);
     $parentOid = spl_object_hash($parentDocument);
     $actualData = array();
     foreach ($class->reflFields as $name => $refProp) {
         $mapping = $class->fieldMappings[$name];
         if (!$class->isIdentifier($name) || $class->getAllowCustomID()) {
             $actualData[$name] = $class->getFieldValue($document, $mapping['fieldName']);
         }
         if (($class->isCollectionValuedReference($name) || $class->isCollectionValuedEmbed($name)) && $actualData[$name] !== null && !$actualData[$name] instanceof PersistentCollection) {
             // If $actualData[$name] is not a Collection then use an ArrayCollection.
             if (!$actualData[$name] instanceof Collection) {
                 $actualData[$name] = new ArrayCollection($actualData[$name]);
             }
             // Inject PersistentCollection
             if ($class->isCollectionValuedReference($name)) {
                 $coll = new PersistentCollection($actualData[$name], $this->dm);
             } else {
                 $coll = new PersistentCollection($actualData[$name]);
             }
             $coll->setOwner($document, $mapping);
             $coll->setDirty(!$coll->isEmpty());
             $class->reflFields[$name]->setValue($document, $coll);
             $actualData[$name] = $coll;
         } elseif ($class->isSingleValuedEmbed($name) && is_object($actualData[$name])) {
             $embeddedDocument = $actualData[$name];
             $embeddedMetadata = $this->dm->getClassMetadata(get_class($embeddedDocument));
             $actualData[$name] = array();
             foreach ($embeddedMetadata->fieldMappings as $mapping) {
                 $actualData[$name][$mapping['fieldName']] = $embeddedMetadata->getFieldValue($embeddedDocument, $mapping['fieldName']);
             }
             $actualData[$name]['originalObject'] = $embeddedDocument;
         }
     }
     if (!isset($this->originalDocumentData[$oid])) {
         // Document is either NEW or MANAGED but not yet fully persisted (only has an id).
         // These result in an INSERT.
         $this->originalDocumentData[$oid] = $actualData;
         $changeSet = array();
         foreach ($actualData as $propName => $actualValue) {
             $changeSet[$propName] = array(null, $actualValue);
         }
         $this->documentChangeSets[$oid] = $changeSet;
     } else {
         // Document is "fully" MANAGED: it was already fully persisted before
         // and we have a copy of the original data
         $originalData = $this->originalDocumentData[$oid];
         $isChangeTrackingNotify = $class->isChangeTrackingNotify();
         $changeSet = $isChangeTrackingNotify ? $this->documentChangeSets[$oid] : array();
         foreach ($actualData as $propName => $actualValue) {
             $orgValue = isset($originalData[$propName]) ? $originalData[$propName] : null;
             if ($orgValue instanceof PersistentCollection) {
                 $orgValue = $orgValue->getSnapshot();
             }
             if ($actualValue instanceof PersistentCollection) {
                 $actualValue = $actualValue->toArray();
             }
             if (isset($class->fieldMappings[$propName]['embedded']) && $class->fieldMappings[$propName]['type'] === 'one' && $orgValue !== $actualValue) {
                 if (is_object($orgValue)) {
                     $embeddedOid = spl_object_hash($orgValue);
                     $orgValue = isset($this->originalDocumentData[$embeddedOid]) ? $this->originalDocumentData[$embeddedOid] : $orgValue;
                 }
                 $changeSet[$propName] = array($orgValue, $actualValue);
             } else {
                 if (isset($class->fieldMappings[$propName]['reference']) && $class->fieldMappings[$propName]['type'] === 'one' && $orgValue !== $actualValue) {
                     if (is_object($orgValue)) {
                         $referenceOid = spl_object_hash($orgValue);
                         $orgValue = isset($this->originalDocumentData[$referenceOid]) ? $this->originalDocumentData[$referenceOid] : $orgValue;
                     }
                     $changeSet[$propName] = array($orgValue, $actualValue);
                 } else {
//.........这里部分代码省略.........

 /**
  * Computes the changes that happened to a single document.
  *
  * Modifies/populates the following properties:
  *
  * {@link _originalDocumentData}
  * If the document is NEW or MANAGED but not yet fully persisted (only has an id)
  * then it was not fetched from the database and therefore we have no original
  * document data yet. All of the current document data is stored as the original document data.
  *
  * {@link _documentChangeSets}
  * The changes detected on all properties of the document are stored there.
  * A change is a tuple array where the first entry is the old value and the second
  * entry is the new value of the property. Changesets are used by persisters
  * to INSERT/UPDATE the persistent document state.
  *
  * {@link _documentUpdates}
  * If the document is already fully MANAGED (has been fetched from the database before)
  * and any changes to its properties are detected, then a reference to the document is stored
  * there to mark it for an update.
  *
  * @param object $parentDocument The top most parent document of the document we are computing.
  * @param ClassMetadata $class The class descriptor of the document.
  * @param object $document The document for which to compute the changes.
  */
 public function computeChangeSet($parentDocument, Mapping\ClassMetadata $class, $document)
 {
     if (!$class->isInheritanceTypeNone()) {
         $class = $this->dm->getClassMetadata(get_class($document));
     }
     $oid = spl_object_hash($document);
     $actualData = $this->getDocumentActualData($document);
     if (!isset($this->originalDocumentData[$oid])) {
         // Document is either NEW or MANAGED but not yet fully persisted (only has an id).
         // These result in an INSERT.
         $this->originalDocumentData[$oid] = $actualData;
         $changeSet = array();
         foreach ($actualData as $propName => $actualValue) {
             $changeSet[$propName] = array(null, $actualValue);
         }
         $this->documentChangeSets[$oid] = $changeSet;
     } else {
         // Document is "fully" MANAGED: it was already fully persisted before
         // and we have a copy of the original data
         $originalData = $this->originalDocumentData[$oid];
         $isChangeTrackingNotify = $class->isChangeTrackingNotify();
         $changeSet = $isChangeTrackingNotify ? $this->documentChangeSets[$oid] : array();
         foreach ($actualData as $propName => $actualValue) {
             $orgValue = isset($originalData[$propName]) ? $originalData[$propName] : null;
             if ($orgValue instanceof PersistentCollection) {
                 $orgValue = $orgValue->getSnapshot();
             }
             if ($actualValue instanceof PersistentCollection) {
                 $actualValue = $actualValue->toArray();
             }
             if (isset($class->fieldMappings[$propName]['embedded']) && $class->fieldMappings[$propName]['type'] === 'one' && $orgValue !== $actualValue) {
                 if (is_object($orgValue)) {
                     $embeddedOid = spl_object_hash($orgValue);
                     $orgValue = isset($this->originalDocumentData[$embeddedOid]) ? $this->originalDocumentData[$embeddedOid] : $orgValue;
                 }
                 $changeSet[$propName] = array($orgValue, $actualValue);
             } else {
                 if (isset($class->fieldMappings[$propName]['reference']) && $class->fieldMappings[$propName]['type'] === 'one' && $orgValue !== $actualValue) {
                     if (is_object($orgValue)) {
                         $referenceOid = spl_object_hash($orgValue);
                         $orgValue = isset($this->originalDocumentData[$referenceOid]) ? $this->originalDocumentData[$referenceOid] : $orgValue;
                     }
                     $changeSet[$propName] = array($orgValue, $actualValue);
                 } else {
                     if ($isChangeTrackingNotify) {
                         continue;
                     } else {
                         if (isset($class->fieldMappings[$propName]['type']) && $class->fieldMappings[$propName]['type'] === 'many') {
                             $changeSet[$propName] = array($orgValue, $actualValue);
                         } else {
                             if (is_object($orgValue) && $orgValue !== $actualValue) {
                                 $changeSet[$propName] = array($orgValue, $actualValue);
                             } else {
                                 if ($orgValue != $actualValue || $orgValue === null ^ $actualValue === null) {
                                     $changeSet[$propName] = array($orgValue, $actualValue);
                                 }
                             }
                         }
                     }
                 }
             }
         }
         if ($changeSet) {
             $this->documentChangeSets[$oid] = $changeSet;
             $this->originalDocumentData[$oid] = $actualData;
             if (!$class->isEmbeddedDocument) {
                 $this->documentUpdates[$oid] = $document;
             }
         }
     }
     // Look for changes in references of the document
     foreach ($class->fieldMappings as $mapping) {
         if (isset($mapping['reference']) || isset($mapping['embedded'])) {
             $val = $class->reflFields[$mapping['fieldName']]->getValue($document);
             if ($val !== null) {
//.........这里部分代码省略.........