PHP Classes::classOfValue方法代码示例

 public static function encodeResponseForSuccess(Method $serviceMethod, $object, SerializationPolicy $serializationPolicy = null, $flags = AbstractSerializationStream::DEFAULT_FLAGS)
 {
     if (is_null($serviceMethod)) {
         throw new NullPointerException('serviceMethod cannot be null');
     }
     if (is_null($serializationPolicy)) {
         $serializationPolicy = self::getDefaultSerializationPolicy();
         throw new NullPointerException('serializationPolicy cannot be null');
     }
     $methodReturnTypeName = $serviceMethod->getReturnType();
     //TODO see if must be an object
     if (empty($methodReturnTypeName)) {
         $methodReturnType = Void::typeClass();
     } else {
         $methodReturnType = Classes::classOf($methodReturnTypeName);
     }
     if ($methodReturnType !== Void::typeClass() && !is_null($object)) {
         // TODO : Verify
         /*if ($methodReturnType->isPrimitive()) {
         			$actualReturnType = self::getPrimitiveClassFromWrapper(Classes::classOf($object));
         		}
         		else {
         			$actualReturnType = Classes::classOf($object);
         		}*/
         $actualReturnType = Classes::classOfValue($object);
         //var_dump($methodReturnType);
         // TODO : Enum manage
         if ($methodReturnType->isEnum() && $actualReturnType === Integer::typeClass()) {
             return self::encodeResponse($methodReturnType, $object, false, $flags, $serializationPolicy);
         }
         if (is_null($actualReturnType) || !$methodReturnType->isAssignableFrom($actualReturnType)) {
             $printedType = self::printTypeName(Classes::classOfValue($object));
             $source = self::getSourceRepresentation($serviceMethod);
             throw new IllegalArgumentException("Type '{$printedType}' does not match the return type in the method's signature : '{$source}'");
         }
     }
     return self::encodeResponse($methodReturnType, $object, false, $flags, $serializationPolicy);
 }

 public static function autoClass(array &$value)
 {
     $type = null;
     for ($i = 0; $i < count($value); $i++) {
         $itype = Classes::classOfValue($value[$i]);
         if (is_null($type)) {
             $type = $itype;
         } else {
             if ($type != $itype) {
                 return self::clazz(Object::clazz(), 1);
             }
         }
     }
     return self::clazz($type, 1);
 }

 private function makeObject(Clazz $type, $value)
 {
     // no anonymous class, and no local class in php
     $manualType = $type;
     $customSerializer = null;
     do {
         $customSerializer = SerializabilityUtil::hasCustomFieldSerializer($manualType);
         if ($customSerializer != null) {
             break;
         }
         $manualType = $manualType->getSuperClass();
     } while ($manualType != null);
     $ins = null;
     if ($customSerializer != null) {
         $ins = $this->serializeWithCustomSerializer($customSerializer, $value, $type, $manualType);
     } else {
         $ins = new InstantiateCommand($type);
         $this->identityMap->put($value, $ins);
     }
     if ($type != $manualType) {
         if (!Classes::classOf('GWTSerializable')->isAssignableFrom($type) && !Classes::classOf('IsSerializable')->isAssignableFrom($type)) {
             throw new SerializationException($type->getName() . ' is not a serializable type');
         }
     }
     while ($type != $manualType) {
         $serializableFields = $this->clientOracle->getOperableFields($type);
         foreach ($serializableFields as $declField) {
             assert($declField != null);
             //echo '[' . $declField->getName() . ' = ' . $declField->getType() . ']<br />';
             $accessor = Accessors::get($declField->getType());
             $valueCommand = null;
             $fieldValue = $accessor->get($value, $declField);
             if (is_null($fieldValue)) {
                 $valueCommand = NullValueCommand::INSTANCE();
             } else {
                 $fieldType = $declField->getType()->isPrimitive() ? $declField->getType() : ($declField->hasType() ? $declField->getType() : Classes::classOfValue($fieldValue));
                 $valueCommand = $this->makeValue($fieldType, $fieldValue);
             }
             //echo '{set ' . $declField->getDeclaringClass()->getName() . ' / ' . $declField->getName() . ' / ' . $valueCommand . '}';
             $ins->set($declField->getDeclaringClass(), $declField->getName(), $valueCommand);
         }
         $type = $type->getSuperClass();
     }
     return $ins;
 }

 private static function getClassForSerialization($instance, Clazz $instanceClass = null)
 {
     assert(!is_null($instance));
     /*if ($instance instanceof SerializedEnum) {
     			return $instance->getEnumClass();
     		}*/
     // TODO if enum
     /*if (instance instanceof Enum<?>) {
         Enum<?> e = (Enum<?>) instance;
         return e.getDeclaringClass();
       } else {
         return instance.getClass();
       }*/
     if (is_null($instanceClass)) {
         return Classes::classOfValue($instance);
     } else {
         return $instanceClass;
     }
 }