/**
* Analyzes the Object Configuration provided by the compiler and builds the necessary PHP code for the proxy classes
* to realize dependency injection.
*
* @return void
*/
public function build()
{
$this->objectConfigurations = $this->objectManager->getObjectConfigurations();
foreach ($this->objectConfigurations as $objectName => $objectConfiguration) {
$className = $objectConfiguration->getClassName();
if ($this->compiler->hasCacheEntryForClass($className) === TRUE) {
continue;
}
if ($objectName !== $className || $this->reflectionService->isClassAbstract($className) || $this->reflectionService->isClassFinal($className)) {
continue;
}
$proxyClass = $this->compiler->getProxyClass($className);
if ($proxyClass === FALSE) {
continue;
}
$this->systemLogger->log('Building DI proxy for "' . $className . '".', LOG_DEBUG);
$constructorPreCode = '';
$constructorPostCode = '';
$constructorPreCode .= $this->buildSetInstanceCode($objectConfiguration);
$constructorPreCode .= $this->buildConstructorInjectionCode($objectConfiguration);
$wakeupMethod = $proxyClass->getMethod('__wakeup');
$wakeupMethod->addPreParentCallCode($this->buildSetInstanceCode($objectConfiguration));
$wakeupMethod->addPreParentCallCode($this->buildSetRelatedEntitiesCode());
$wakeupMethod->addPostParentCallCode($this->buildLifecycleInitializationCode($objectConfiguration, \TYPO3\FLOW3\Object\ObjectManagerInterface::INITIALIZATIONCAUSE_RECREATED));
$wakeupMethod->addPostParentCallCode($this->buildLifecycleShutdownCode($objectConfiguration));
$sleepMethod = $proxyClass->getMethod('__sleep');
$sleepMethod->addPostParentCallCode($this->buildSerializeRelatedEntitiesCode($objectConfiguration));
$searchForEntitiesAndStoreIdentifierArrayMethod = $proxyClass->getMethod('searchForEntitiesAndStoreIdentifierArray');
$searchForEntitiesAndStoreIdentifierArrayMethod->setMethodParametersCode('$path, $propertyValue, $originalPropertyName');
$searchForEntitiesAndStoreIdentifierArrayMethod->overrideMethodVisibility('private');
$searchForEntitiesAndStoreIdentifierArrayMethod->addPreParentCallCode($this->buildSearchForEntitiesAndStoreIdentifierArrayCode());
$injectPropertiesCode = $this->buildPropertyInjectionCode($objectConfiguration);
if ($injectPropertiesCode !== '') {
$proxyClass->getMethod('FLOW3_Proxy_injectProperties')->addPreParentCallCode($injectPropertiesCode);
$proxyClass->getMethod('FLOW3_Proxy_injectProperties')->overrideMethodVisibility('private');
$wakeupMethod->addPreParentCallCode("\t\t\$this->FLOW3_Proxy_injectProperties();\n");
$constructorPostCode .= ' if (\'' . $className . '\' === get_class($this)) {' . "\n";
$constructorPostCode .= ' $this->FLOW3_Proxy_injectProperties();' . "\n";
$constructorPostCode .= ' }' . "\n";
}
$constructorPostCode .= $this->buildLifecycleInitializationCode($objectConfiguration, \TYPO3\FLOW3\Object\ObjectManagerInterface::INITIALIZATIONCAUSE_CREATED);
$constructorPostCode .= $this->buildLifecycleShutdownCode($objectConfiguration);
$constructor = $proxyClass->getConstructor();
$constructor->addPreParentCallCode($constructorPreCode);
$constructor->addPostParentCallCode($constructorPostCode);
}
}
/**
* Renders and returns the PHP code for this ProxyClass.
*
* @return string
*/
public function render()
{
$namespace = $this->namespace;
$proxyClassName = $this->originalClassName;
$originalClassName = $this->originalClassName . \TYPO3\FLOW3\Object\Proxy\Compiler::ORIGINAL_CLASSNAME_SUFFIX;
$abstractKeyword = $this->reflectionService->isClassAbstract($this->fullOriginalClassName) ? 'abstract ' : '';
$constantsCode = $this->renderConstantsCode();
$propertiesCode = $this->renderPropertiesCode();
$methodsCode = isset($this->constructor) ? $this->constructor->render() : '';
foreach ($this->methods as $proxyMethod) {
$methodsCode .= $proxyMethod->render();
}
if ($methodsCode . $constantsCode === '') {
return '';
}
$classCode = "namespace {$namespace};\n" . "\n" . "use Doctrine\\ORM\\Mapping as ORM;\n" . "use TYPO3\\FLOW3\\Annotations as FLOW3;\n" . "\n" . $this->buildClassDocumentation() . $abstractKeyword . "class {$proxyClassName} extends {$originalClassName} implements " . implode(', ', array_unique($this->interfaces)) . " {\n\n" . $constantsCode . $propertiesCode . $methodsCode . "}";
return $classCode;
}
/**
* Loads the metadata for the specified class into the provided container.
*
* @param string $className
* @param \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata
* @return void
* @throws \Doctrine\ORM\Mapping\MappingException
* @throws \UnexpectedValueException
* @todo adjust when Doctrine 2 supports value objects, see http://www.doctrine-project.org/jira/browse/DDC-93
*/
public function loadMetadataForClass($className, \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata)
{
$class = $metadata->getReflectionClass();
$classSchema = $this->getClassSchema($class->getName());
$classAnnotations = $this->reader->getClassAnnotations($class);
// Evaluate Entity annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\MappedSuperclass'])) {
$mappedSuperclassAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\MappedSuperclass'];
if ($mappedSuperclassAnnotation->repositoryClass !== NULL) {
$metadata->setCustomRepositoryClass($mappedSuperclassAnnotation->repositoryClass);
}
$metadata->isMappedSuperclass = TRUE;
} elseif (isset($classAnnotations['TYPO3\\FLOW3\\Annotations\\Entity']) || isset($classAnnotations['Doctrine\\ORM\\Mapping\\Entity'])) {
$entityAnnotation = isset($classAnnotations['TYPO3\\FLOW3\\Annotations\\Entity']) ? $classAnnotations['TYPO3\\FLOW3\\Annotations\\Entity'] : $classAnnotations['Doctrine\\ORM\\Mapping\\Entity'];
if ($entityAnnotation->repositoryClass !== NULL) {
$metadata->setCustomRepositoryClass($entityAnnotation->repositoryClass);
} elseif ($classSchema->getRepositoryClassName() !== NULL) {
if ($this->reflectionService->isClassImplementationOf($classSchema->getRepositoryClassName(), 'Doctrine\\ORM\\EntityRepository')) {
$metadata->setCustomRepositoryClass($classSchema->getRepositoryClassName());
}
}
if ($entityAnnotation->readOnly) {
$metadata->markReadOnly();
}
} elseif ($classSchema->getModelType() === \TYPO3\FLOW3\Reflection\ClassSchema::MODELTYPE_VALUEOBJECT) {
// also ok... but we make it read-only
$metadata->markReadOnly();
} else {
throw \Doctrine\ORM\Mapping\MappingException::classIsNotAValidEntityOrMappedSuperClass($className);
}
// Evaluate Table annotation
$primaryTable = array();
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\Table'])) {
$tableAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\Table'];
$primaryTable['name'] = $tableAnnotation->name;
$primaryTable['schema'] = $tableAnnotation->schema;
if ($tableAnnotation->indexes !== NULL) {
foreach ($tableAnnotation->indexes as $indexAnnotation) {
$index = array('columns' => $indexAnnotation->columns);
if (!empty($indexAnnotation->name)) {
$primaryTable['indexes'][$indexAnnotation->name] = $index;
} else {
$primaryTable['indexes'][] = $index;
}
}
}
if ($tableAnnotation->uniqueConstraints !== NULL) {
foreach ($tableAnnotation->uniqueConstraints as $uniqueConstraint) {
$uniqueConstraint = array('columns' => $uniqueConstraint->columns);
if (!empty($uniqueConstraint->name)) {
$primaryTable['uniqueConstraints'][$uniqueConstraint->name] = $uniqueConstraint;
} else {
$primaryTable['uniqueConstraints'][] = $uniqueConstraint;
}
}
}
}
if (!isset($primaryTable['name'])) {
$className = $classSchema->getClassName();
$primaryTable['name'] = $this->inferTableNameFromClassName($className);
}
// Evaluate NamedQueries annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\NamedQueries'])) {
$namedQueriesAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\NamedQueries'];
if (!is_array($namedQueriesAnnotation->value)) {
throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
}
foreach ($namedQueriesAnnotation->value as $namedQuery) {
if (!$namedQuery instanceof \Doctrine\ORM\Mapping\NamedQuery) {
throw new \UnexpectedValueException("@NamedQueries should contain an array of @NamedQuery annotations.");
}
$metadata->addNamedQuery(array('name' => $namedQuery->name, 'query' => $namedQuery->query));
}
}
// Evaluate InheritanceType annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\InheritanceType'])) {
$inheritanceTypeAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\InheritanceType'];
$metadata->setInheritanceType(constant('Doctrine\\ORM\\Mapping\\ClassMetadata::INHERITANCE_TYPE_' . strtoupper($inheritanceTypeAnnotation->value)));
if ($metadata->inheritanceType !== \Doctrine\ORM\Mapping\ClassMetadata::INHERITANCE_TYPE_NONE) {
// Evaluate DiscriminatorColumn annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\DiscriminatorColumn'])) {
$discriminatorColumnAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\DiscriminatorColumn'];
$metadata->setDiscriminatorColumn(array('name' => $discriminatorColumnAnnotation->name, 'type' => $discriminatorColumnAnnotation->type, 'length' => $discriminatorColumnAnnotation->length));
} else {
$metadata->setDiscriminatorColumn(array('name' => 'dtype', 'type' => 'string', 'length' => 255));
}
// Evaluate DiscriminatorMap annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\DiscriminatorMap'])) {
$discriminatorMapAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\DiscriminatorMap'];
$metadata->setDiscriminatorMap($discriminatorMapAnnotation->value);
} else {
$discriminatorMap = array();
$subclassNames = $this->reflectionService->getAllSubClassNamesForClass($className);
if (!$this->reflectionService->isClassAbstract($className)) {
$mappedClassName = strtolower(str_replace('Domain_Model_', '', str_replace('\\', '_', $className)));
$discriminatorMap[$mappedClassName] = $className;
}
foreach ($subclassNames as $subclassName) {
$mappedSubclassName = strtolower(str_replace('Domain_Model_', '', str_replace('\\', '_', $subclassName)));
$discriminatorMap[$mappedSubclassName] = $subclassName;
}
$metadata->setDiscriminatorMap($discriminatorMap);
}
}
}
// Evaluate DoctrineChangeTrackingPolicy annotation
if (isset($classAnnotations['Doctrine\\ORM\\Mapping\\ChangeTrackingPolicy'])) {
$changeTrackingAnnotation = $classAnnotations['Doctrine\\ORM\\Mapping\\ChangeTrackingPolicy'];
$metadata->setChangeTrackingPolicy(constant('Doctrine\\ORM\\Mapping\\ClassMetadata::CHANGETRACKING_' . strtoupper($changeTrackingAnnotation->value)));
} else {
$metadata->setChangeTrackingPolicy(\Doctrine\ORM\Mapping\ClassMetadata::CHANGETRACKING_DEFERRED_EXPLICIT);
}
// Evaluate annotations on properties/fields
$this->evaluatePropertyAnnotations($metadata);
// build unique index for table
if (!isset($primaryTable['uniqueConstraints'])) {
$idProperties = array_keys($classSchema->getIdentityProperties());
if (array_diff($idProperties, $metadata->getIdentifierFieldNames()) !== array()) {
$uniqueIndexName = $this->truncateIdentifier('flow3_identity_' . $primaryTable['name']);
foreach ($idProperties as $idProperty) {
$primaryTable['uniqueConstraints'][$uniqueIndexName]['columns'][] = isset($metadata->columnNames[$idProperty]) ? $metadata->columnNames[$idProperty] : strtolower($idProperty);
}
}
}
$metadata->setPrimaryTable($primaryTable);
// Evaluate @HasLifecycleCallbacks annotation
$this->evaluateLifeCycleAnnotations($class, $metadata);
}
