/**
* 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);
}
}
