fieldRequired() public static method

public static fieldRequired ( $entityName, $fieldName )
示例#1
0
 /**
  *
  * INTERNAL: Performance sensitive method
  *
  * @throws \Doctrine\OXM\Mapping\MappingException
  * @param \XMLReader $cursor
  * @return object
  */
 private function doUnmarshal(XMLReader $cursor)
 {
     $allMappedXmlNodes = $this->classMetadataFactory->getAllXmlNodes();
     $knownMappedNodes = array_keys($allMappedXmlNodes);
     if ($cursor->nodeType !== XMLReader::ELEMENT) {
         throw MarshallerException::invalidMarshallerState($cursor);
     }
     $elementName = $cursor->localName;
     if (!in_array($elementName, $knownMappedNodes)) {
         throw MappingException::invalidMapping($elementName);
     }
     $classMetadata = $this->classMetadataFactory->getMetadataFor($allMappedXmlNodes[$elementName]);
     $mappedObject = $classMetadata->newInstance();
     // Pre Unmarshal hook
     if ($classMetadata->hasLifecycleCallbacks(Events::preUnmarshal)) {
         $classMetadata->invokeLifecycleCallbacks(Events::preUnmarshal, $mappedObject);
     }
     if ($cursor->hasAttributes) {
         while ($cursor->moveToNextAttribute()) {
             if ($classMetadata->hasXmlField($cursor->name)) {
                 $fieldName = $classMetadata->getFieldName($cursor->name);
                 $fieldMapping = $classMetadata->getFieldMapping($fieldName);
                 $type = Type::getType($fieldMapping['type']);
                 if ($classMetadata->isRequired($fieldName) && $cursor->value === null) {
                     throw MappingException::fieldRequired($classMetadata->name, $fieldName);
                 }
                 if ($classMetadata->isCollection($fieldName)) {
                     $convertedValues = array();
                     foreach (explode(" ", $cursor->value) as $value) {
                         $convertedValues[] = $type->convertToPHPValue($value);
                     }
                     $classMetadata->setFieldValue($mappedObject, $fieldName, $convertedValues);
                 } else {
                     $classMetadata->setFieldValue($mappedObject, $fieldName, $type->convertToPHPValue($cursor->value));
                 }
             }
         }
         $cursor->moveToElement();
     }
     if (!$cursor->isEmptyElement) {
         $collectionElements = array();
         while (true) {
             $cursor->read();
             if ($cursor->nodeType === XMLReader::END_ELEMENT && $cursor->name === $elementName) {
                 // we're at the original element closing node, bug out
                 break;
             }
             if ($cursor->nodeType !== XMLReader::ELEMENT) {
                 // skip insignificant elements
                 continue;
             }
             if ($classMetadata->hasXmlField($cursor->localName)) {
                 $fieldName = $classMetadata->getFieldName($cursor->localName);
                 // Check for mapped entity as child, add recursively
                 $fieldMapping = $classMetadata->getFieldMapping($fieldName);
                 if ($this->classMetadataFactory->hasMetadataFor($fieldMapping['type'])) {
                     if ($classMetadata->isCollection($fieldName)) {
                         $collectionElements[$fieldName][] = $this->doUnmarshal($cursor);
                     } else {
                         $classMetadata->setFieldValue($mappedObject, $fieldName, $this->doUnmarshal($cursor));
                     }
                 } else {
                     // assume text element (dangerous?)
                     $cursor->read();
                     if ($cursor->nodeType !== XMLReader::TEXT) {
                         throw MarshallerException::invalidMarshallerState($cursor);
                     }
                     $type = Type::getType($fieldMapping['type']);
                     if ($classMetadata->isCollection($fieldName)) {
                         $collectionElements[$fieldName][] = $type->convertToPHPValue($cursor->value);
                     } else {
                         $classMetadata->setFieldValue($mappedObject, $fieldName, $type->convertToPHPValue($cursor->value));
                     }
                     $cursor->read();
                 }
             } elseif (in_array($cursor->name, $knownMappedNodes)) {
                 // look for inherited child directly
                 $childClassMetadata = $this->classMetadataFactory->getMetadataFor($allMappedXmlNodes[$cursor->name]);
                 // todo: ensure this potential child inherits from parent correctly
                 $fieldName = null;
                 foreach ($classMetadata->getFieldMappings() as $fieldMapping) {
                     if ($fieldMapping['type'] == $allMappedXmlNodes[$cursor->name]) {
                         $fieldName = $fieldMapping['fieldName'];
                     } else {
                         // Walk parent tree
                         foreach ($childClassMetadata->getParentClasses() as $parentClass) {
                             if ($fieldMapping['type'] == $parentClass) {
                                 $fieldName = $fieldMapping['fieldName'];
                             }
                         }
                     }
                 }
                 if ($fieldName !== null) {
                     if ($classMetadata->isCollection($fieldName)) {
                         $collectionElements[$fieldName][] = $this->doUnmarshal($cursor);
                     } else {
                         $classMetadata->setFieldValue($mappedObject, $fieldName, $this->doUnmarshal($cursor));
                     }
                 }
             }
         }
         if (!empty($collectionElements)) {
             foreach ($collectionElements as $fieldName => $elements) {
                 $classMetadata->setFieldValue($mappedObject, $fieldName, $elements);
             }
         }
     }
     // PostUnmarshall hook
     if ($classMetadata->hasLifecycleCallbacks(Events::postUnmarshal)) {
         $classMetadata->invokeLifecycleCallbacks(Events::postUnmarshal, $mappedObject);
     }
     return $mappedObject;
 }
 /**
  *
  * INTERNAL: Performance sensitive method
  *
  * @throws \Doctrine\OXM\Mapping\MappingException
  * @param \XMLReader $cursor
  * @return object
  */
 private function doUnmarshal(XMLReader $cursor, $endElement = NULL, $classMetadata = NULL, $virtualNamespace = NULL)
 {
     /*
     $allMappedXmlNodes = $this->classMetadataFactory->getAllXmlNodes();
     $allMappedWrapperXmlNodes = $this->classMetadataFactory->getAllWrapperXmlNodes();
     */
     static $allMappedXmlNodes, $allMappedWrapperXmlNodes, $alternativeClasses;
     if (empty($allMappedXmlNodes)) {
         list($allMappedXmlNodes, $allMappedWrapperXmlNodes, $alternativeClasses) = $this->classMetadataFactory->getAllMaps();
     }
     if ($cursor->nodeType !== XMLReader::ELEMENT && $cursor->nodeType !== XMLReader::CDATA) {
         throw MarshallerException::invalidMarshallerState($cursor);
     }
     $elementName = $cursor->localName;
     if (!empty($classMetadata)) {
         $isInWrapper = !empty($endElement);
     } else {
         $isInWrapper = FALSE;
         if (!array_key_exists($elementName, $allMappedXmlNodes) && !array_key_exists($elementName, $allMappedWrapperXmlNodes) && !array_key_exists('*', $allMappedXmlNodes)) {
             if ($this->allowUnknownElements) {
                 return $this->doUnmarshalUnknownElement($cursor, $endElement, $classMetadata, $virtualNamespace);
             } else {
                 throw MappingException::invalidMapping($elementName);
             }
         }
         if (array_key_exists($elementName, $allMappedXmlNodes)) {
             $classes = $allMappedXmlNodes[$elementName];
         } else {
             $classes = $allMappedXmlNodes['*'];
         }
         if (count($classes) == 1) {
             $namespaces = array_keys($classes);
             $className = $classes[array_shift($namespaces)];
         } else {
             // Should try to work out the correct namespace version here
             $attributes = $this->getElementAttributes($cursor);
             $attributes['-name'] = $cursor->localName;
             foreach ($classes as $thisClass) {
                 $className = $this->classMetadataFactory->getAlternativeClassForNamespace($thisClass, $virtualNamespace, FALSE);
                 if (!$className) {
                     $className = $this->classMetadataFactory->getAlternativeClassForAttributes($thisClass, $virtualNamespace, $attributes, FALSE);
                 }
                 if (!$className) {
                     break;
                 }
             }
             if (!$className) {
                 $namespaces = array_keys($classes);
                 $className = $classes[array_shift($namespaces)];
                 error_log('Scream: too many choices! Selected ${className} for ${elementName}');
                 error_log(print_r($classes, TRUE));
             }
         }
         $classMetadata = $this->classMetadataFactory->getMetadataFor($className);
     }
     $mappedObject = $classMetadata->newInstance();
     // Pre Unmarshal hook -- doesn't make sense on the wrapper
     if ($classMetadata->hasLifecycleCallbacks(Events::preUnmarshal)) {
         $classMetadata->invokeLifecycleCallbacks(Events::preUnmarshal, $mappedObject);
     }
     if (!$isInWrapper && $cursor->hasAttributes) {
         while ($cursor->moveToNextAttribute()) {
             if ($classMetadata->hasXmlField($cursor->name)) {
                 $fieldName = $classMetadata->getFieldName($cursor->name);
                 $fieldMapping = $classMetadata->getFieldMapping($fieldName);
                 $type = Type::getType($fieldMapping['type']);
                 if ($classMetadata->isRequired($fieldName) && $cursor->value === null) {
                     throw MappingException::fieldRequired($classMetadata->name, $fieldName);
                 }
                 if ($classMetadata->isCollection($fieldName) || $isInWrapper) {
                     $convertedValues = array();
                     foreach (explode(" ", $cursor->value) as $value) {
                         $convertedValues[] = $type->convertToPHPValue($value);
                     }
                     $classMetadata->setFieldValue($mappedObject, $fieldName, $convertedValues);
                 } else {
                     $classMetadata->setFieldValue($mappedObject, $fieldName, $type->convertToPHPValue($cursor->value));
                 }
             }
         }
         $cursor->moveToElement();
     }
     if (!$cursor->isEmptyElement) {
         $collectionElements = array();
         while ($cursor->read()) {
             if ($cursor->nodeType === XMLReader::END_ELEMENT && ($cursor->name === $elementName || $isInWrapper && $cursor->name === $endElement)) {
                 // we're at the original element closing node, bug out
                 break;
             }
             if ($cursor->nodeType !== XMLReader::ELEMENT && $cursor->nodeType !== XMLReader::TEXT && $cursor->nodeType !== XMLReader::CDATA) {
                 // skip insignificant elements
                 continue;
             }
             if ($classMetadata->hasXmlField($cursor->localName) || $classMetadata->hasXmlField('*')) {
                 $fieldName = $classMetadata->getFieldName($cursor->localName);
                 $inAnyMode = FALSE;
                 if (!$fieldName) {
                     $fieldName = $classMetadata->getFieldName('*');
                     $inAnyMode = TRUE;
                 }
                 // Check for mapped entity as child, add recursively
                 $fieldMapping = $classMetadata->getFieldMapping($fieldName);
                 if ($this->classMetadataFactory->hasMetadataFor($fieldMapping['type'])) {
                     $namespace = $cursor->namespaceURI ? $cursor->namespaceURI : $virtualNamespace;
                     $childClass = NULL;
                     if ($inAnyMode) {
                         $childClass = $this->classMetadataFactory->getAlternativeClassForNamespace($fieldMapping['type'], $namespace, FALSE);
                         if (!$childClass) {
                             $childClass = $this->classMetadataFactory->getAlternativeClassForName($fieldMapping['type'], $cursor->localName, FALSE);
                         }
                         if (!$childClass) {
                             // Check the global mapping
                             if (!empty($allMappedXmlNodes[$cursor->localName])) {
                                 $childClass = $allMappedXmlNodes[$cursor->localName];
                                 if (is_array($childClass)) {
                                     $childClass = array_shift($childClass);
                                 }
                             }
                         }
                     }
                     if (empty($childClass)) {
                         $attributes = $this->getElementAttributes($cursor);
                         $attributes['-name'] = $cursor->localName;
                         $childClass = $this->classMetadataFactory->getAlternativeClassForAttributes($fieldMapping['type'], $namespace, $attributes, FALSE);
                         if (!$childClass) {
                             $childClass = $this->classMetadataFactory->getAlternativeClassForNamespace($fieldMapping['type'], $namespace);
                         }
                     }
                     $childClassMetadata = $this->classMetadataFactory->getMetadataFor($childClass);
                     if ($classMetadata->hasFieldWrapping($fieldName) && !$isInWrapper) {
                         $cursor->moveToElement();
                         $collectionElements[$fieldName] = $this->doUnmarshal($cursor, $fieldName, $classMetadata, $namespace);
                     } elseif ($classMetadata->isCollection($fieldName) || $isInWrapper) {
                         $collectionElements[$fieldName][] = $this->doUnmarshal($cursor, NULL, $childClassMetadata, $namespace);
                     } else {
                         $classMetadata->setFieldValue($mappedObject, $fieldName, $this->doUnmarshal($cursor, NULL, $childClassMetadata, $namespace));
                     }
                 } elseif ($cursor->isEmptyElement) {
                     // Don't move on just yet!
                     $type = Type::getType($fieldMapping['type']);
                     if ($classMetadata->isCollection($fieldName) || $isInWrapper) {
                         $collectionElements[$fieldName][] = $type->convertToPHPValue($cursor->value);
                     } else {
                         $classMetadata->setFieldValue($mappedObject, $fieldName, $type->convertToPHPValue($cursor->value));
                     }
                     // Still don't move on as the loop will
                 } else {
                     // assume text element (dangerous?)
                     $cursor->read();
                     if (!$cursor->isEmptyElement && $cursor->nodeType !== XMLReader::END_ELEMENT) {
                         if ($cursor->nodeType !== XMLReader::TEXT && $cursor->nodeType !== XMLReader::CDATA) {
                             throw MarshallerException::invalidMarshallerState($cursor);
                         }
                         $type = Type::getType($fieldMapping['type']);
                         if ($classMetadata->isCollection($fieldName) || $isInWrapper) {
                             $collectionElements[$fieldName][] = $type->convertToPHPValue($cursor->value);
                         } else {
                             $classMetadata->setFieldValue($mappedObject, $fieldName, $type->convertToPHPValue($cursor->value));
                         }
                         $cursor->read();
                     }
                 }
             } elseif ($cursor->nodeType === XMLReader::TEXT || $cursor->nodeType === XMLReader::CDATA) {
                 foreach ($classMetadata->getFieldNames() as $fieldName) {
                     if (ClassMetadata::XML_VALUE === $classMetadata->getFieldXmlNode($fieldName)) {
                         $fieldMapping = $classMetadata->getFieldMapping($fieldName);
                         $type = Type::getType($fieldMapping['type']);
                         $classMetadata->setFieldValue($mappedObject, $fieldName, $type->convertToPHPValue($cursor->value));
                     }
                 }
             } elseif (array_key_exists($cursor->name, $allMappedXmlNodes) || array_key_exists($cursor->name, $allMappedWrapperXmlNodes) && isset($allMappedWrapperXmlNodes[$cursor->name][$elementName])) {
                 // look for inherited child directly
                 if (array_key_exists($cursor->name, $allMappedWrapperXmlNodes) && isset($allMappedWrapperXmlNodes[$cursor->name][$elementName])) {
                     if ($allMappedWrapperXmlNodes[$cursor->name][$elementName] === NULL) {
                         $childClassMetadata = NULL;
                     } else {
                         $childClassMetadata = $this->classMetadataFactory->getMetadataFor($allMappedWrapperXmlNodes[$cursor->name][$elementName]);
                     }
                 } elseif (isset($allMappedXmlNodes[$cursor->name])) {
                     if (is_array($allMappedXmlNodes[$cursor->name])) {
                         // FIXME: This is fragile as it doesn't account for the same xml name being used more than once
                         $childClasses = array_values($allMappedXmlNodes[$cursor->name]);
                         $childClass = array_shift($childClasses);
                     } else {
                         $childClass = $allMappedXmlNodes[$cursor->name];
                     }
                     $childClassMetadata = $this->classMetadataFactory->getMetadataFor($childClass);
                 }
                 // todo: ensure this potential child inherits from parent correctly
                 $fieldName = null;
                 $isWrapper = FALSE;
                 foreach ($classMetadata->getFieldMappings() as $fieldMapping) {
                     if (isset($allMappedXmlNodes[$cursor->name]) && $fieldMapping['type'] == $allMappedXmlNodes[$cursor->name]) {
                         $fieldName = $fieldMapping['fieldName'];
                         break;
                     } elseif (isset($allMappedWrapperXmlNodes[$cursor->name][$elementName]) && $fieldMapping['type'] == $allMappedWrapperXmlNodes[$cursor->name][$elementName]) {
                         $fieldName = $fieldMapping['fieldName'];
                         $isWrapper = TRUE;
                         break;
                     } else {
                         // Walk parent tree
                         if (!isset($childClassMetadata)) {
                             continue;
                         }
                         foreach ($childClassMetadata->getParentClasses() as $parentClass) {
                             if ($fieldMapping['type'] == $parentClass) {
                                 $fieldName = $fieldMapping['fieldName'];
                                 break 2;
                             }
                         }
                     }
                 }
                 if ($fieldName !== null) {
                     $namespace = $cursor->namespaceURI ? $cursor->namespaceURI : $virtualNamespace;
                     if ($isWrapper) {
                         $thisFieldMapping = $classMetadata->getFieldMapping($fieldName);
                         $childEndElement = $thisFieldMapping['wrapper'];
                         $childElements = $this->doUnmarshal($cursor, $childEndElement, $classMetadata, $namespace);
                         $collectionElements[$fieldName] = $childElements;
                     } elseif ($classMetadata->isCollection($fieldName)) {
                         $collectionElements[$fieldName][] = $this->doUnmarshal($cursor, NULL, NULL, $namespace);
                     } else {
                         $classMetadata->setFieldValue($mappedObject, $fieldName, $this->doUnmarshal($cursor, NULL, NULL, $namespace));
                     }
                 }
             } elseif ($this->allowUnknownElements) {
                 $elementName = $cursor->name;
                 $mappedObject->{$elementName} = $this->doUnmarshalUnknownElement($cursor, $endElement, $classMetadata, $virtualNamespace);
             }
         }
         if (!empty($collectionElements)) {
             if (!$isInWrapper || !isset($fieldName)) {
                 foreach ($collectionElements as $fieldName => $elements) {
                     $classMetadata->setFieldValue($mappedObject, $fieldName, $elements);
                 }
             } else {
                 if (!empty($collectionElements[$fieldName]) && (is_array($collectionElements[$fieldName]) && !empty($collectionElements[$fieldName][0]))) {
                     $mappedObject = $collectionElements[$fieldName];
                 }
             }
         }
     }
     if (!$isInWrapper) {
         // PostUnmarshall hook
         if ($classMetadata->hasLifecycleCallbacks(Events::postUnmarshal)) {
             $classMetadata->invokeLifecycleCallbacks(Events::postUnmarshal, $mappedObject);
         }
     }
     return $mappedObject;
 }