/**
* Gets a reference to the document identified by the given type and identifier
* without actually loading it.
*
* If partial objects are allowed, this method will return a partial object that only
* has its identifier populated. Otherwise a proxy is returned that automatically
* loads itself on first access.
*
* @return object The document reference.
*/
public function getReference($documentName, $identifier)
{
$class = $this->_metadataFactory->getMetadataFor($documentName);
// Check identity map first, if its already in there just return it.
if ($document = $this->_unitOfWork->tryGetById($identifier, $class->rootDocumentName)) {
return $document;
}
$document = $this->_proxyFactory->getProxy($class->name, $identifier);
$this->_unitOfWork->registerManaged($document, $identifier, array());
return $document;
}
/**
* Gets a partial reference to the document identified by the given type and identifier
* without actually loading it, if the document is not yet loaded.
*
* The returned reference may be a partial object if the document is not yet loaded/managed.
* If it is a partial object it will not initialize the rest of the document state on access.
* Thus you can only ever safely access the identifier of an document obtained through
* this method.
*
* The use-cases for partial references involve maintaining bidirectional associations
* without loading one side of the association or to update an document without loading it.
* Note, however, that in the latter case the original (persistent) document data will
* never be visible to the application (especially not event listeners) as it will
* never be loaded in the first place.
*
* @param string $documentName The name of the document type.
* @param mixed $identifier The document identifier.
* @return object The (partial) document reference.
*/
public function getPartialReference($documentName, $identifier)
{
$class = $this->metadataFactory->getMetadataFor($documentName);
// Check identity map first, if its already in there just return it.
if ($document = $this->unitOfWork->tryGetById($identifier, $class->rootDocumentName)) {
return $document;
}
$document = $class->newInstance();
$class->setIdentifierValue($document, $identifier);
$this->unitOfWork->registerManaged($document, $identifier, array());
return $document;
}
private function doGenericHydration(ClassMetadata $metadata, $document, $data)
{
foreach ($metadata->fieldMappings as $mapping) {
// Find the raw value. It may be in one of the mapped alsoLoadFields.
$found = false;
if (isset($mapping['alsoLoadFields']) && $mapping['alsoLoadFields']) {
foreach ($mapping['alsoLoadFields'] as $name) {
if (isset($data[$name])) {
$rawValue = $data[$name];
$found = true;
break;
}
}
}
// If nothing then lets get it from the default mapping field name
if ($found === false) {
$rawValue = isset($data[$mapping['name']]) ? $data[$mapping['name']] : null;
}
$value = null;
// Prepare the different types of mapped values converting them from the MongoDB
// types to the portable Doctrine types.
// @Field
if (!isset($mapping['association'])) {
$value = Type::getType($mapping['type'])->convertToPHPValue($rawValue);
// @ReferenceOne
} elseif ($mapping['association'] === ClassMetadata::REFERENCE_ONE) {
$reference = $rawValue;
if ($reference === null || !isset($reference[$this->cmd . 'id'])) {
continue;
}
$className = $this->dm->getClassNameFromDiscriminatorValue($mapping, $reference);
$targetMetadata = $this->dm->getClassMetadata($className);
$id = $targetMetadata->getPHPIdentifierValue($reference[$this->cmd . 'id']);
$value = $this->dm->getReference($className, $id);
// @ReferenceMany and @EmbedMany
} elseif ($mapping['association'] === ClassMetadata::REFERENCE_MANY || $mapping['association'] === ClassMetadata::EMBED_MANY) {
$value = new PersistentCollection(new ArrayCollection(), $this->dm, $this->unitOfWork, $this->cmd);
$value->setOwner($document, $mapping);
$value->setInitialized(false);
if ($rawValue) {
$value->setMongoData($rawValue);
}
// @EmbedOne
} elseif ($mapping['association'] === ClassMetadata::EMBED_ONE) {
if ($rawValue === null) {
continue;
}
$embeddedDocument = $rawValue;
$className = $this->dm->getClassNameFromDiscriminatorValue($mapping, $embeddedDocument);
$embeddedMetadata = $this->dm->getClassMetadata($className);
$value = $embeddedMetadata->newInstance();
$embeddedHydratedData = $this->hydrate($value, $embeddedDocument);
$this->unitOfWork->registerManaged($value, null, $embeddedHydratedData);
$this->unitOfWork->setParentAssociation($value, $mapping, $document, $mapping['name']);
}
unset($data[$mapping['name']]);
// Hydrate the prepared value to the document
if ($value !== null) {
$metadata->reflFields[$mapping['fieldName']]->setValue($document, $value);
$data[$mapping['fieldName']] = $value;
}
}
return $data;
}
