PHP TypeHandling::truncateElementType方法代码示例

 /**
  * @test
  * @dataProvider compositeTypes
  */
 public function extractCollectionTypeReturnsOnlyTheMainType($type, $expectedResult)
 {
     $this->assertEquals($expectedResult, TypeHandling::truncateElementType($type), 'Failed for ' . $type);
 }

 /**
  * Tries to find a suitable type converter for the given source and target type.
  *
  * @param string $source The actual source value
  * @param string $sourceType Type of the source to convert from
  * @param string $targetType Name of the target type to find a type converter for
  * @return mixed Either the matching object converter or NULL
  * @throws \TYPO3\Flow\Property\Exception\InvalidTargetException
  */
 protected function findFirstEligibleTypeConverterInObjectHierarchy($source, $sourceType, $targetType)
 {
     $targetClass = TypeHandling::truncateElementType($targetType);
     if (!class_exists($targetClass) && !interface_exists($targetClass)) {
         throw new \TYPO3\Flow\Property\Exception\InvalidTargetException(sprintf('Could not find a suitable type converter for "%s" because no such the class/interface "%s" does not exist.', $targetType, $targetClass), 1297948764);
     }
     if (!isset($this->typeConverters[$sourceType])) {
         return null;
     }
     $convertersForSource = $this->typeConverters[$sourceType];
     if (isset($convertersForSource[$targetClass])) {
         $converter = $this->findEligibleConverterWithHighestPriority($convertersForSource[$targetClass], $source, $targetType);
         if ($converter !== null) {
             return $converter;
         }
     }
     foreach (class_parents($targetClass) as $parentClass) {
         if (!isset($convertersForSource[$parentClass])) {
             continue;
         }
         $converter = $this->findEligibleConverterWithHighestPriority($convertersForSource[$parentClass], $source, $targetType);
         if ($converter !== null) {
             return $converter;
         }
     }
     $converters = $this->getConvertersForInterfaces($convertersForSource, class_implements($targetClass));
     $converter = $this->findEligibleConverterWithHighestPriority($converters, $source, $targetType);
     if ($converter !== null) {
         return $converter;
     }
     if (isset($convertersForSource['object'])) {
         return $this->findEligibleConverterWithHighestPriority($convertersForSource['object'], $source, $targetType);
     } else {
         return null;
     }
 }

 /**
  * @test
  * @dataProvider convertCallsCanConvertFromWithTheFullNormalizedTargetTypeDataProvider
  */
 public function convertCallsCanConvertFromWithTheFullNormalizedTargetType($source, $fullTargetType)
 {
     $mockTypeConverter = $this->getMockTypeConverter();
     $mockTypeConverter->expects($this->atLeastOnce())->method('canConvertFrom')->with($source, $fullTargetType);
     $truncatedTargetType = TypeHandling::truncateElementType($fullTargetType);
     $mockTypeConverters = array(gettype($source) => array($truncatedTargetType => array(1 => $mockTypeConverter)));
     $propertyMapper = $this->getAccessibleMock('TYPO3\\Flow\\Property\\PropertyMapper', array('dummy'));
     $propertyMapper->_set('typeConverters', $mockTypeConverters);
     $mockConfiguration = $this->getMockBuilder('TYPO3\\Flow\\Property\\PropertyMappingConfiguration')->disableOriginalConstructor()->getMock();
     $propertyMapper->convert($source, $fullTargetType, $mockConfiguration);
     // dummy assertion to avoid PHPUnit warning
     $this->assertTrue(TRUE);
 }

 /**
  * @param mixed $propertyValue
  * @param string $dataType
  * @return mixed
  * @throws PropertyException
  */
 protected function convertValue($propertyValue, $dataType)
 {
     $rawType = TypeHandling::truncateElementType($dataType);
     // This hardcoded handling is to circumvent rewriting PropertyMappers that convert objects. Usually they expect the source to be an object already and break if not.
     if (!TypeHandling::isSimpleType($rawType) && !is_object($propertyValue) && !is_array($propertyValue)) {
         return null;
     }
     if ($rawType === 'array') {
         $conversionTargetType = 'array<string>';
     } elseif (TypeHandling::isSimpleType($rawType)) {
         $conversionTargetType = TypeHandling::normalizeType($rawType);
     } else {
         $conversionTargetType = 'array';
     }
     $propertyMappingConfiguration = $this->createConfiguration($dataType);
     $convertedValue = $this->propertyMapper->convert($propertyValue, $conversionTargetType, $propertyMappingConfiguration);
     if ($convertedValue instanceof \TYPO3\Flow\Error\Error) {
         throw new PropertyException($convertedValue->getMessage(), $convertedValue->getCode());
     }
     return $convertedValue;
 }