/** * Enter description here... * * @param MappedClass $mappedClass * @return ReflectionClass */ public static function computeHasCustomFieldSerializer(MappedClass $instanceType) { assert($instanceType != null); $qualifiedTypeName = null; if ($instanceType->isArray()) { /*MappedClass*/ $componentType = $instanceType->getComponentType(); if ($componentType->isPrimitive()) { $qualifiedTypeName = 'java.lang.' . $componentType->getName(); } else { $qualifiedTypeName = 'java.lang.Object'; } $qualifiedTypeName .= '_Array'; } else { $qualifiedTypeName = $instanceType->getName(); } $classLoader = GWTPHPContext::getInstance()->getClassLoader(); $simpleSerializerName = $qualifiedTypeName . "_CustomFieldSerializer"; $customSerializer = SerializabilityUtil::getCustomFieldSerializer($classLoader, $simpleSerializerName); if ($customSerializer != null) { return $customSerializer; } // Try with the regular name /*ReflectionClass*/ $customSerializerClass = SerializabilityUtil::getCustomFieldSerializer($classLoader, SerializabilityUtil::$JRE_SERIALIZER_PACKAGE . '.' . $simpleSerializerName); if ($customSerializerClass != null) { return $customSerializerClass; } return null; }
/** * Straight copy from * {@link com.google.gwt.dev.util.TypeInfo#getSourceRepresentation(Class)} to * avoid runtime dependency on gwt-dev. */ private static function printTypeName(MappedClass $type) { // Primitives // if ($type->isPrimitive()) { switch ($type) { case TypeSignatures::$BOOLEAN: return 'boolean'; case TypeSignatures::$BYTE: return 'byte'; case TypeSignatures::$CHAR: return 'char'; case TypeSignatures::$DOUBLE: return 'double'; case TypeSignatures::$FLOAT: return 'float'; case TypeSignatures::$INT: return 'int'; case TypeSignatures::$LONG: return 'long'; case TypeSignatures::$SHORT: return 'short'; default: 'unknown'; } } // Arrays // if ($type->isArray()) { $componentType = $type->getComponentType(); return RPC::printTypeName($componentType) + '[]'; } // Everything else // return $type->getName(); //.replace('$', '.'); }
/** * Enter description here... * * @param MappedClass $mappedClass * @return ReflectionClass */ public static function hasCustomFieldSerializer(MappedClass $instanceType) { assert($instanceType != null); if ($instanceType->isArray()) { return null; } $result = SerializabilityUtil::getCachedSerializerForClass($instanceType); if ($result !== null) { // this class has a custom serializer return $result; } if (SerializabilityUtil::containsCachedSerializerForClass($instanceType)) { // this class definitely has no custom serializer return null; } // compute whether this class has a custom serializer $result = SerializabilityUtil::computeHasCustomFieldSerializer($instanceType); SerializabilityUtil::putCachedSerializerForClass($instanceType, $result); return $result; }
private function deserializeWithCustomFieldDeserializer(ReflectionClass $customSerializer, MappedClass $instanceClass, $instance) { // return $customSerializer->deserialize() // throw new Exception('Unsuporter operation exception'); if ($instanceClass->isArray()) { /*MappedClass*/ $componentType = $instanceClass->getComponentType(); if (!$componentType->isPrimitive()) { $instanceClass = array(); //Class.forName("[Ljava.lang.Object;"); } } /*MappedMethod*/ $deserialize = $customSerializer->getMethod("deserialize"); //SerializationStreamReader.class, instanceClass); $deserialize->invoke(null, $this, &$instance); }
/** * Instantiable types are primitives, {@line IsSerializable}, types with * custom serializers, and any arrays of those types. Merely * {@link Serializable} types cannot be instantiated or serialized directly * (only as super types of legacy serializable types). * @param MappedClass $mappedClass * @return boolean */ private function isInstantiable(MappedClass $mappedClass) { if ($mappedClass->isPrimitive()) { return true; } if ($mappedClass->isArray()) { return $this->isInstantiable($mappedClass->getComponentType()); } if ($mappedClass->getReflectionClass() != null && $mappedClass->getReflectionClass()->isSubclassOf(SerializationPolicy::$IS_SERIALIZABLE_INTERFACE_CLASS_NAME)) { return true; } //if (IsSerializable.class.isAssignableFrom(clazz)) { // return true; //} return SerializabilityUtil::hasCustomFieldSerializer($mappedClass) != null; }
/** * @param MappedClass $instanceClass * @param Object $instance */ private function deserializeArray(MappedClass $instanceClass, BoundedList &$instance) { assert($instanceClass->isArray()); //assert($instance instanceof BoundedList); $s = $instanceClass->getSignature(); /*VectorReader */ $instanceReader = self::$CLASS_TO_VECTOR_READER[$s]; if ($instanceReader !== null) { return $instanceReader->read($this, $instance); } else { return VectorReader::OBJECT_VECTOR()->read($this, $instance); } }
/** * Serialize an instance that is an array. Will default to serializing the * instance as an Object vector if the instance is not a vector of primitives, * Strings or Object. * * @param MappedClass instanceClass * @param Object instance * @throws SerializationException */ private function serializeArray(MappedClass $instanceClass, $instance) { assert($instanceClass->isArray()); $s = $instanceClass->getSignature(); /*VectorWriter */ $instanceReader = self::$CLASS_TO_VECTOR_WRITER[$s]; if ($instanceReader != null) { $instanceReader->write($this, $instance, $instanceClass); } else { VectorWriter::OBJECT_VECTOR()->write($this, $instance, $instanceClass); } }