/**
* Overrides an already defined type to use a different implementation.
*
* @static
* @param string $name
* @param string $className
* @throws MappingException
*/
public static function overrideType($name, $className)
{
if (!isset(self::$typesMap[$name])) {
throw MappingException::typeNotFound($name);
}
self::$typesMap[$name] = $className;
}
/**
* Gets the mapping of a field.
*
* @param string $fieldName The field name.
*
* @return array The field mapping.
*
* @throws MappingException if the $fieldName is not found in the fieldMappings array
*
* @throws MappingException
*/
public function getFieldMapping($fieldName)
{
if (!isset($this->fieldMappings[$fieldName])) {
throw MappingException::mappingNotFound($this->name, $fieldName);
}
return $this->fieldMappings[$fieldName];
}
private function completeIdGeneratorMapping(ClassMetadataInfo $class)
{
$idGenOptions = $class->generatorOptions;
switch ($class->generatorType) {
case ClassMetadata::GENERATOR_TYPE_AUTO:
$class->setIdGenerator(new \CosmoW\ODM\Riak\Id\AutoGenerator($class));
break;
case ClassMetadata::GENERATOR_TYPE_INCREMENT:
$incrementGenerator = new \CosmoW\ODM\Riak\Id\IncrementGenerator($class);
if (isset($idGenOptions['key'])) {
$incrementGenerator->setKey($idGenOptions['key']);
}
if (isset($idGenOptions['collection'])) {
$incrementGenerator->setCollection($idGenOptions['collection']);
}
$class->setIdGenerator($incrementGenerator);
break;
case ClassMetadata::GENERATOR_TYPE_UUID:
$uuidGenerator = new \CosmoW\ODM\Riak\Id\UuidGenerator($class);
isset($idGenOptions['salt']) && $uuidGenerator->setSalt($idGenOptions['salt']);
$class->setIdGenerator($uuidGenerator);
break;
case ClassMetadata::GENERATOR_TYPE_ALNUM:
$alnumGenerator = new \CosmoW\ODM\Riak\Id\AlnumGenerator($class);
if (isset($idGenOptions['pad'])) {
$alnumGenerator->setPad($idGenOptions['pad']);
}
if (isset($idGenOptions['chars'])) {
$alnumGenerator->setChars($idGenOptions['chars']);
} elseif (isset($idGenOptions['awkwardSafe'])) {
$alnumGenerator->setAwkwardSafeMode($idGenOptions['awkwardSafe']);
}
$class->setIdGenerator($alnumGenerator);
break;
case ClassMetadata::GENERATOR_TYPE_CUSTOM:
if (empty($idGenOptions['class'])) {
throw MappingException::missingIdGeneratorClass($class->name);
}
$customGenerator = new $idGenOptions['class']();
unset($idGenOptions['class']);
if (!$customGenerator instanceof \CosmoW\ODM\Riak\Id\AbstractIdGenerator) {
throw MappingException::classIsNotAValidGenerator(get_class($customGenerator));
}
$methods = get_class_methods($customGenerator);
foreach ($idGenOptions as $name => $value) {
$method = 'set' . ucfirst($name);
if (!in_array($method, $methods)) {
throw MappingException::missingGeneratorSetter(get_class($customGenerator), $name);
}
$customGenerator->{$method}($value);
}
$class->setIdGenerator($customGenerator);
break;
case ClassMetadata::GENERATOR_TYPE_NONE:
break;
default:
throw new MappingException("Unknown generator type: " . $class->generatorType);
}
}
/**
* Returns a DBRef array for the supplied document.
*
* @param mixed $document A document object
* @param array $referenceMapping Mapping for the field that references the document
*
* @throws \InvalidArgumentException
* @return array A DBRef array
*/
public function createDBRef($document, array $referenceMapping = null)
{
if (!is_object($document)) {
throw new \InvalidArgumentException('Cannot create a DBRef, the document is not an object');
}
$class = $this->getClassMetadata(get_class($document));
$id = $this->unitOfWork->getDocumentIdentifier($document);
if (!$id) {
throw new \RuntimeException(sprintf('Cannot create a DBRef for class %s without an identifier. Have you forgotten to persist/merge the document first?', $class->name));
}
if (!empty($referenceMapping['simple'])) {
if ($class->inheritanceType === ClassMetadataInfo::INHERITANCE_TYPE_SINGLE_COLLECTION) {
throw MappingException::simpleReferenceMustNotTargetDiscriminatedDocument($referenceMapping['targetDocument']);
}
return $class->getDatabaseIdentifierValue($id);
}
$dbRef = array('$ref' => $class->getCollection(), '$id' => $class->getDatabaseIdentifierValue($id), '$db' => $this->getDocumentDatabase($class->name)->getName());
/* If the class has a discriminator (field and value), use it. A child
* class that is not defined in the discriminator map may only have a
* discriminator field and no value, so default to the full class name.
*/
if (isset($class->discriminatorField)) {
$dbRef[$class->discriminatorField] = isset($class->discriminatorValue) ? $class->discriminatorValue : $class->name;
}
/* Add a discriminator value if the referenced document is not mapped
* explicitly to a targetDocument class.
*/
if ($referenceMapping !== null && !isset($referenceMapping['targetDocument'])) {
$discriminatorField = $referenceMapping['discriminatorField'];
$discriminatorValue = isset($referenceMapping['discriminatorMap']) ? array_search($class->name, $referenceMapping['discriminatorMap']) : $class->name;
/* If the discriminator value was not found in the map, use the full
* class name. In the future, it may be preferable to throw an
* exception here (perhaps based on some strictness option).
*
* @see PersistenceBuilder::prepareEmbeddedDocumentValue()
*/
if ($discriminatorValue === false) {
$discriminatorValue = $class->name;
}
$dbRef[$discriminatorField] = $discriminatorValue;
}
return $dbRef;
}
/**
* {@inheritdoc}
*/
public function loadMetadataForClass($className, ClassMetadata $class)
{
/** @var $class ClassMetadataInfo */
$reflClass = $class->getReflectionClass();
$classAnnotations = $this->reader->getClassAnnotations($reflClass);
$documentAnnots = array();
foreach ($classAnnotations as $annot) {
$classAnnotations[get_class($annot)] = $annot;
foreach ($this->entityAnnotationClasses as $annotClass => $i) {
if ($annot instanceof $annotClass) {
$documentAnnots[$i] = $annot;
continue 2;
}
}
// non-document class annotations
if ($annot instanceof ODM\AbstractIndex) {
$this->addIndex($class, $annot);
}
if ($annot instanceof ODM\Indexes) {
foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
$this->addIndex($class, $index);
}
} elseif ($annot instanceof ODM\InheritanceType) {
$class->setInheritanceType(constant('Doctrine\\ODM\\Riak\\Mapping\\ClassMetadata::INHERITANCE_TYPE_' . $annot->value));
} elseif ($annot instanceof ODM\DiscriminatorField) {
// $fieldName property is deprecated, but fall back for BC
if (isset($annot->value)) {
$class->setDiscriminatorField($annot->value);
} elseif (isset($annot->name)) {
$class->setDiscriminatorField($annot->name);
} elseif (isset($annot->fieldName)) {
$class->setDiscriminatorField($annot->fieldName);
}
} elseif ($annot instanceof ODM\DiscriminatorMap) {
$class->setDiscriminatorMap($annot->value);
} elseif ($annot instanceof ODM\DiscriminatorValue) {
$class->setDiscriminatorValue($annot->value);
} elseif ($annot instanceof ODM\ChangeTrackingPolicy) {
$class->setChangeTrackingPolicy(constant('Doctrine\\ODM\\Riak\\Mapping\\ClassMetadata::CHANGETRACKING_' . $annot->value));
} elseif ($annot instanceof ODM\DefaultDiscriminatorValue) {
$class->setDefaultDiscriminatorValue($annot->value);
}
}
if (!$documentAnnots) {
throw MappingException::classIsNotAValidDocument($className);
}
// find the winning document annotation
ksort($documentAnnots);
$documentAnnot = reset($documentAnnots);
if ($documentAnnot instanceof ODM\MappedSuperclass) {
$class->isMappedSuperclass = true;
} elseif ($documentAnnot instanceof ODM\EmbeddedDocument) {
$class->isEmbeddedDocument = true;
}
if (isset($documentAnnot->db)) {
$class->setDatabase($documentAnnot->db);
}
if (isset($documentAnnot->collection)) {
$class->setCollection($documentAnnot->collection);
}
if (isset($documentAnnot->repositoryClass) && !$class->isEmbeddedDocument) {
$class->setCustomRepositoryClass($documentAnnot->repositoryClass);
}
if (isset($documentAnnot->indexes)) {
foreach ($documentAnnot->indexes as $index) {
$this->addIndex($class, $index);
}
}
if (isset($documentAnnot->requireIndexes)) {
$class->setRequireIndexes($documentAnnot->requireIndexes);
}
if (isset($documentAnnot->slaveOkay)) {
$class->setSlaveOkay($documentAnnot->slaveOkay);
}
foreach ($reflClass->getProperties() as $property) {
if ($class->isMappedSuperclass && !$property->isPrivate() || $class->isInheritedField($property->name) && $property->getDeclaringClass()->name !== $class->name) {
continue;
}
$indexes = array();
$mapping = array('fieldName' => $property->getName());
$fieldAnnot = null;
foreach ($this->reader->getPropertyAnnotations($property) as $annot) {
if ($annot instanceof ODM\AbstractField) {
$fieldAnnot = $annot;
}
if ($annot instanceof ODM\AbstractIndex) {
$indexes[] = $annot;
}
if ($annot instanceof ODM\Indexes) {
foreach (is_array($annot->value) ? $annot->value : array($annot->value) as $index) {
$indexes[] = $index;
}
} elseif ($annot instanceof ODM\AlsoLoad) {
$mapping['alsoLoadFields'] = (array) $annot->value;
} elseif ($annot instanceof ODM\Version) {
$mapping['version'] = true;
} elseif ($annot instanceof ODM\Lock) {
$mapping['lock'] = true;
}
}
if ($fieldAnnot) {
$mapping = array_replace($mapping, (array) $fieldAnnot);
$class->mapField($mapping);
}
if ($indexes) {
foreach ($indexes as $index) {
$name = isset($mapping['name']) ? $mapping['name'] : $mapping['fieldName'];
$keys = array($name => $index->order ?: 'asc');
$this->addIndex($class, $index, $keys);
}
}
}
/** @var $method \ReflectionMethod */
foreach ($reflClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
/* Filter for the declaring class only. Callbacks from parent
* classes will already be registered.
*/
if ($method->getDeclaringClass()->name !== $reflClass->name) {
continue;
}
foreach ($this->reader->getMethodAnnotations($method) as $annot) {
if ($annot instanceof ODM\AlsoLoad) {
$class->registerAlsoLoadMethod($method->getName(), $annot->value);
}
if (!isset($classAnnotations['CosmoW\\ODM\\Riak\\Mapping\\Annotations\\HasLifecycleCallbacks'])) {
continue;
}
if ($annot instanceof ODM\PrePersist) {
$class->addLifecycleCallback($method->getName(), Events::prePersist);
} elseif ($annot instanceof ODM\PostPersist) {
$class->addLifecycleCallback($method->getName(), Events::postPersist);
} elseif ($annot instanceof ODM\PreUpdate) {
$class->addLifecycleCallback($method->getName(), Events::preUpdate);
} elseif ($annot instanceof ODM\PostUpdate) {
$class->addLifecycleCallback($method->getName(), Events::postUpdate);
} elseif ($annot instanceof ODM\PreRemove) {
$class->addLifecycleCallback($method->getName(), Events::preRemove);
} elseif ($annot instanceof ODM\PostRemove) {
$class->addLifecycleCallback($method->getName(), Events::postRemove);
} elseif ($annot instanceof ODM\PreLoad) {
$class->addLifecycleCallback($method->getName(), Events::preLoad);
} elseif ($annot instanceof ODM\PostLoad) {
$class->addLifecycleCallback($method->getName(), Events::postLoad);
} elseif ($annot instanceof ODM\PreFlush) {
$class->addLifecycleCallback($method->getName(), Events::preFlush);
}
}
}
}