,
+ protected val proxyClass: Class,
+ protected val factory: SerializerFactory,
+ val withInheritance: Boolean = true) : CustomSerializer() {
+ override fun isSerializerFor(clazz: Class<*>): Boolean = if (withInheritance) this.clazz.isAssignableFrom(clazz) else this.clazz == clazz
+ override val type: Type get() = clazz
+ override val typeDescriptor: String = "$DESCRIPTOR_DOMAIN:${clazz.name}"
+ override fun writeClassInfo(output: SerializationOutput) {}
+ override val descriptor: Descriptor = Descriptor(typeDescriptor)
+
+ private val proxySerializer: ObjectSerializer by lazy { ObjectSerializer(proxyClass, factory) }
+
+ override val schemaForDocumentation: Schema by lazy {
+ val typeNotations = mutableSetOf(CompositeType(type.typeName, null, emptyList(), descriptor, (proxySerializer.typeNotation as CompositeType).fields))
+ for (additional in additionalSerializers) {
+ typeNotations.addAll(additional.schemaForDocumentation.types)
+ }
+ Schema(typeNotations.toList())
+ }
+
+ /**
+ * Implement these two methods.
+ */
+ protected abstract fun toProxy(obj: T): P
+
+ protected abstract fun fromProxy(proxy: P): T
+
+ override fun writeDescribedObject(obj: T, data: Data, type: Type, output: SerializationOutput) {
+ val proxy = toProxy(obj)
+ data.withList {
+ for (property in proxySerializer.propertySerializers) {
+ property.writeProperty(proxy, this, output)
+ }
+ }
+ }
+
+ override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): T {
+ @Suppress("UNCHECKED_CAST")
+ val proxy = proxySerializer.readObject(obj, schema, input) as P
+ return fromProxy(proxy)
+ }
+ }
+}
diff --git a/core/src/main/kotlin/net/corda/core/serialization/amqp/DeserializationInput.kt b/core/src/main/kotlin/net/corda/core/serialization/amqp/DeserializationInput.kt
index b47d75b8bc..ccbe1fac20 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/amqp/DeserializationInput.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/amqp/DeserializationInput.kt
@@ -15,7 +15,7 @@ import java.util.*
* @param serializerFactory This is the factory for [AMQPSerializer] instances and can be shared across multiple
* instances and threads.
*/
-class DeserializationInput(private val serializerFactory: SerializerFactory = SerializerFactory()) {
+class DeserializationInput(internal val serializerFactory: SerializerFactory = SerializerFactory()) {
// TODO: we're not supporting object refs yet
private val objectHistory: MutableList = ArrayList()
@@ -41,7 +41,7 @@ class DeserializationInput(private val serializerFactory: SerializerFactory = Se
}
val envelope = Envelope.get(data)
// Now pick out the obj and schema from the envelope.
- return clazz.cast(readObjectOrNull(envelope.obj, envelope, clazz))
+ return clazz.cast(readObjectOrNull(envelope.obj, envelope.schema, clazz))
} catch(nse: NotSerializableException) {
throw nse
} catch(t: Throwable) {
@@ -51,20 +51,21 @@ class DeserializationInput(private val serializerFactory: SerializerFactory = Se
}
}
- internal fun readObjectOrNull(obj: Any?, envelope: Envelope, type: Type): Any? {
+ internal fun readObjectOrNull(obj: Any?, schema: Schema, type: Type): Any? {
if (obj == null) {
return null
} else {
- return readObject(obj, envelope, type)
+ return readObject(obj, schema, type)
}
}
- internal fun readObject(obj: Any, envelope: Envelope, type: Type): Any {
+ internal fun readObject(obj: Any, schema: Schema, type: Type): Any {
if (obj is DescribedType) {
// Look up serializer in factory by descriptor
- val serializer = serializerFactory.get(obj.descriptor, envelope)
- if (serializer.type != type && !serializer.type.isSubClassOf(type)) throw NotSerializableException("Described type with descriptor ${obj.descriptor} was expected to be of type $type")
- return serializer.readObject(obj.described, envelope, this)
+ val serializer = serializerFactory.get(obj.descriptor, schema)
+ if (serializer.type != type && !serializer.type.isSubClassOf(type))
+ throw NotSerializableException("Described type with descriptor ${obj.descriptor} was expected to be of type $type")
+ return serializer.readObject(obj.described, schema, this)
} else {
return obj
}
diff --git a/core/src/main/kotlin/net/corda/core/serialization/amqp/DeserializedParameterizedType.kt b/core/src/main/kotlin/net/corda/core/serialization/amqp/DeserializedParameterizedType.kt
index 2cd0ae1298..9a0809d18d 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/amqp/DeserializedParameterizedType.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/amqp/DeserializedParameterizedType.kt
@@ -119,7 +119,7 @@ class DeserializedParameterizedType(private val rawType: Class<*>, private val p
private fun makeType(typeName: String, cl: ClassLoader): Type {
// Not generic
- return if (typeName == "*") SerializerFactory.AnyType else Class.forName(typeName, false, cl)
+ return if (typeName == "?") SerializerFactory.AnyType else Class.forName(typeName, false, cl)
}
private fun makeParameterizedType(rawTypeName: String, args: MutableList, cl: ClassLoader): Type {
diff --git a/core/src/main/kotlin/net/corda/core/serialization/amqp/MapSerializer.kt b/core/src/main/kotlin/net/corda/core/serialization/amqp/MapSerializer.kt
index 2ea61c6598..7991648f1a 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/amqp/MapSerializer.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/amqp/MapSerializer.kt
@@ -13,10 +13,9 @@ import kotlin.collections.map
/**
* Serialization / deserialization of certain supported [Map] types.
*/
-class MapSerializer(val declaredType: ParameterizedType) : AMQPSerializer {
+class MapSerializer(val declaredType: ParameterizedType, factory: SerializerFactory) : AMQPSerializer {
override val type: Type = declaredType as? DeserializedParameterizedType ?: DeserializedParameterizedType.make(declaredType.toString())
- private val typeName = declaredType.toString()
- override val typeDescriptor = "$DESCRIPTOR_DOMAIN:${fingerprintForType(type)}"
+ override val typeDescriptor = "$DESCRIPTOR_DOMAIN:${fingerprintForType(type, factory)}"
companion object {
private val supportedTypes: Map>, (Map<*, *>) -> Map<*, *>> = mapOf(
@@ -24,15 +23,15 @@ class MapSerializer(val declaredType: ParameterizedType) : AMQPSerializer {
SortedMap::class.java to { map -> Collections.unmodifiableSortedMap(TreeMap(map)) },
NavigableMap::class.java to { map -> Collections.unmodifiableNavigableMap(TreeMap(map)) }
)
+
+ private fun findConcreteType(clazz: Class<*>): (Map<*, *>) -> Map<*, *> {
+ return supportedTypes[clazz] ?: throw NotSerializableException("Unsupported map type $clazz.")
+ }
}
private val concreteBuilder: (Map<*, *>) -> Map<*, *> = findConcreteType(declaredType.rawType as Class<*>)
- private fun findConcreteType(clazz: Class<*>): (Map<*, *>) -> Map<*, *> {
- return supportedTypes[clazz] ?: throw NotSerializableException("Unsupported map type $clazz.")
- }
-
- private val typeNotation: TypeNotation = RestrictedType(typeName, null, emptyList(), "map", Descriptor(typeDescriptor, null), emptyList())
+ private val typeNotation: TypeNotation = RestrictedType(declaredType.toString(), null, emptyList(), "map", Descriptor(typeDescriptor, null), emptyList())
override fun writeClassInfo(output: SerializationOutput) {
if (output.writeTypeNotations(typeNotation)) {
@@ -56,11 +55,13 @@ class MapSerializer(val declaredType: ParameterizedType) : AMQPSerializer {
}
}
- override fun readObject(obj: Any, envelope: Envelope, input: DeserializationInput): Any {
+ override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any {
// TODO: General generics question. Do we need to validate that entries in Maps and Collections match the generic type? Is it a security hole?
- val entries: Iterable> = (obj as Map<*, *>).map { readEntry(envelope, input, it) }
+ val entries: Iterable> = (obj as Map<*, *>).map { readEntry(schema, input, it) }
return concreteBuilder(entries.toMap())
}
- private fun readEntry(envelope: Envelope, input: DeserializationInput, entry: Map.Entry) = input.readObjectOrNull(entry.key, envelope, declaredType.actualTypeArguments[0]) to input.readObjectOrNull(entry.value, envelope, declaredType.actualTypeArguments[1])
+ private fun readEntry(schema: Schema, input: DeserializationInput, entry: Map.Entry) =
+ input.readObjectOrNull(entry.key, schema, declaredType.actualTypeArguments[0]) to
+ input.readObjectOrNull(entry.value, schema, declaredType.actualTypeArguments[1])
}
\ No newline at end of file
diff --git a/core/src/main/kotlin/net/corda/core/serialization/amqp/ObjectSerializer.kt b/core/src/main/kotlin/net/corda/core/serialization/amqp/ObjectSerializer.kt
index 2ccfad81d6..130d50d7a3 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/amqp/ObjectSerializer.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/amqp/ObjectSerializer.kt
@@ -10,26 +10,30 @@ import kotlin.reflect.jvm.javaConstructor
/**
* Responsible for serializing and deserializing a regular object instance via a series of properties (matched with a constructor).
*/
-class ObjectSerializer(val clazz: Class<*>) : AMQPSerializer {
+class ObjectSerializer(val clazz: Class<*>, factory: SerializerFactory) : AMQPSerializer {
override val type: Type get() = clazz
private val javaConstructor: Constructor?
- private val propertySerializers: Collection
+ internal val propertySerializers: Collection
init {
val kotlinConstructor = constructorForDeserialization(clazz)
javaConstructor = kotlinConstructor?.javaConstructor
- propertySerializers = propertiesForSerialization(kotlinConstructor, clazz)
+ propertySerializers = propertiesForSerialization(kotlinConstructor, clazz, factory)
}
private val typeName = clazz.name
- override val typeDescriptor = "$DESCRIPTOR_DOMAIN:${fingerprintForType(type)}"
+ override val typeDescriptor = "$DESCRIPTOR_DOMAIN:${fingerprintForType(type, factory)}"
private val interfaces = interfacesForSerialization(clazz) // TODO maybe this proves too much and we need annotations to restrict.
- private val typeNotation: TypeNotation = CompositeType(typeName, null, generateProvides(), Descriptor(typeDescriptor, null), generateFields())
+ internal val typeNotation: TypeNotation = CompositeType(typeName, null, generateProvides(), Descriptor(typeDescriptor, null), generateFields())
override fun writeClassInfo(output: SerializationOutput) {
- output.writeTypeNotations(typeNotation)
- for (iface in interfaces) {
- output.requireSerializer(iface)
+ if (output.writeTypeNotations(typeNotation)) {
+ for (iface in interfaces) {
+ output.requireSerializer(iface)
+ }
+ for (property in propertySerializers) {
+ property.writeClassInfo(output)
+ }
}
}
@@ -45,13 +49,13 @@ class ObjectSerializer(val clazz: Class<*>) : AMQPSerializer {
}
}
- override fun readObject(obj: Any, envelope: Envelope, input: DeserializationInput): Any {
+ override fun readObject(obj: Any, schema: Schema, input: DeserializationInput): Any {
if (obj is UnsignedInteger) {
// TODO: Object refs
TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
} else if (obj is List<*>) {
if (obj.size > propertySerializers.size) throw NotSerializableException("Too many properties in described type $typeName")
- val params = obj.zip(propertySerializers).map { it.second.readProperty(it.first, envelope, input) }
+ val params = obj.zip(propertySerializers).map { it.second.readProperty(it.first, schema, input) }
return construct(params)
} else throw NotSerializableException("Body of described type is unexpected $obj")
}
diff --git a/core/src/main/kotlin/net/corda/core/serialization/amqp/PropertySerializer.kt b/core/src/main/kotlin/net/corda/core/serialization/amqp/PropertySerializer.kt
index 50cb6c5581..2295a07b45 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/amqp/PropertySerializer.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/amqp/PropertySerializer.kt
@@ -9,8 +9,9 @@ import kotlin.reflect.jvm.javaGetter
* Base class for serialization of a property of an object.
*/
sealed class PropertySerializer(val name: String, val readMethod: Method) {
+ abstract fun writeClassInfo(output: SerializationOutput)
abstract fun writeProperty(obj: Any?, data: Data, output: SerializationOutput)
- abstract fun readProperty(obj: Any?, envelope: Envelope, input: DeserializationInput): Any?
+ abstract fun readProperty(obj: Any?, schema: Schema, input: DeserializationInput): Any?
val type: String = generateType()
val requires: List = generateRequires()
@@ -53,13 +54,13 @@ sealed class PropertySerializer(val name: String, val readMethod: Method) {
}
companion object {
- fun make(name: String, readMethod: Method): PropertySerializer {
+ fun make(name: String, readMethod: Method, factory: SerializerFactory): PropertySerializer {
val type = readMethod.genericReturnType
if (SerializerFactory.isPrimitive(type)) {
// This is a little inefficient for performance since it does a runtime check of type. We could do build time check with lots of subclasses here.
return AMQPPrimitivePropertySerializer(name, readMethod)
} else {
- return DescribedTypePropertySerializer(name, readMethod)
+ return DescribedTypePropertySerializer(name, readMethod) { factory.get(null, type) }
}
}
}
@@ -67,9 +68,16 @@ sealed class PropertySerializer(val name: String, val readMethod: Method) {
/**
* A property serializer for a complex type (another object).
*/
- class DescribedTypePropertySerializer(name: String, readMethod: Method) : PropertySerializer(name, readMethod) {
- override fun readProperty(obj: Any?, envelope: Envelope, input: DeserializationInput): Any? {
- return input.readObjectOrNull(obj, envelope, readMethod.genericReturnType)
+ class DescribedTypePropertySerializer(name: String, readMethod: Method, private val lazyTypeSerializer: () -> AMQPSerializer) : PropertySerializer(name, readMethod) {
+ // This is lazy so we don't get an infinite loop when a method returns an instance of the class.
+ private val typeSerializer: AMQPSerializer by lazy { lazyTypeSerializer() }
+
+ override fun writeClassInfo(output: SerializationOutput) {
+ typeSerializer.writeClassInfo(output)
+ }
+
+ override fun readProperty(obj: Any?, schema: Schema, input: DeserializationInput): Any? {
+ return input.readObjectOrNull(obj, schema, readMethod.genericReturnType)
}
override fun writeProperty(obj: Any?, data: Data, output: SerializationOutput) {
@@ -81,7 +89,9 @@ sealed class PropertySerializer(val name: String, val readMethod: Method) {
* A property serializer for an AMQP primitive type (Int, String, etc).
*/
class AMQPPrimitivePropertySerializer(name: String, readMethod: Method) : PropertySerializer(name, readMethod) {
- override fun readProperty(obj: Any?, envelope: Envelope, input: DeserializationInput): Any? {
+ override fun writeClassInfo(output: SerializationOutput) {}
+
+ override fun readProperty(obj: Any?, schema: Schema, input: DeserializationInput): Any? {
return obj
}
diff --git a/core/src/main/kotlin/net/corda/core/serialization/amqp/Schema.kt b/core/src/main/kotlin/net/corda/core/serialization/amqp/Schema.kt
index 64a28a7aae..5c627cc943 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/amqp/Schema.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/amqp/Schema.kt
@@ -87,7 +87,7 @@ data class Schema(val types: List) : DescribedType {
override fun toString(): String = types.joinToString("\n")
}
-data class Descriptor(val name: String?, val code: UnsignedLong?) : DescribedType {
+data class Descriptor(val name: String?, val code: UnsignedLong? = null) : DescribedType {
companion object : DescribedTypeConstructor {
val DESCRIPTOR = UnsignedLong(3L or DESCRIPTOR_TOP_32BITS)
@@ -320,9 +320,9 @@ private val ANY_TYPE_HASH: String = "Any type = true"
* different.
*/
// TODO: write tests
-internal fun fingerprintForType(type: Type): String = Base58.encode(fingerprintForType(type, HashSet(), Hashing.murmur3_128().newHasher()).hash().asBytes())
+internal fun fingerprintForType(type: Type, factory: SerializerFactory): String = Base58.encode(fingerprintForType(type, HashSet(), Hashing.murmur3_128().newHasher(), factory).hash().asBytes())
-private fun fingerprintForType(type: Type, alreadySeen: MutableSet, hasher: Hasher): Hasher {
+private fun fingerprintForType(type: Type, alreadySeen: MutableSet, hasher: Hasher, factory: SerializerFactory): Hasher {
return if (type in alreadySeen) {
hasher.putUnencodedChars(ALREADY_SEEN_HASH)
} else {
@@ -331,25 +331,31 @@ private fun fingerprintForType(type: Type, alreadySeen: MutableSet, hasher
hasher.putUnencodedChars(ANY_TYPE_HASH)
} else if (type is Class<*>) {
if (type.isArray) {
- fingerprintForType(type.componentType, alreadySeen, hasher).putUnencodedChars(ARRAY_HASH)
+ fingerprintForType(type.componentType, alreadySeen, hasher, factory).putUnencodedChars(ARRAY_HASH)
} else if (SerializerFactory.isPrimitive(type)) {
hasher.putUnencodedChars(type.name)
} else if (Collection::class.java.isAssignableFrom(type) || Map::class.java.isAssignableFrom(type)) {
hasher.putUnencodedChars(type.name)
} else {
- // Hash the class + properties + interfaces
- propertiesForSerialization(constructorForDeserialization(type), type).fold(hasher.putUnencodedChars(type.name)) { orig, param ->
- fingerprintForType(param.readMethod.genericReturnType, alreadySeen, orig).putUnencodedChars(param.name).putUnencodedChars(if (param.mandatory) NOT_NULLABLE_HASH else NULLABLE_HASH)
+ // Need to check if a custom serializer is applicable
+ val customSerializer = factory.findCustomSerializer(type)
+ if (customSerializer == null) {
+ // Hash the class + properties + interfaces
+ propertiesForSerialization(constructorForDeserialization(type), type, factory).fold(hasher.putUnencodedChars(type.name)) { orig, param ->
+ fingerprintForType(param.readMethod.genericReturnType, alreadySeen, orig, factory).putUnencodedChars(param.name).putUnencodedChars(if (param.mandatory) NOT_NULLABLE_HASH else NULLABLE_HASH)
+ }
+ interfacesForSerialization(type).map { fingerprintForType(it, alreadySeen, hasher, factory) }
+ hasher
+ } else {
+ hasher.putUnencodedChars(customSerializer.typeDescriptor)
}
- interfacesForSerialization(type).map { fingerprintForType(it, alreadySeen, hasher) }
- hasher
}
} else if (type is ParameterizedType) {
// Hash the rawType + params
- type.actualTypeArguments.fold(fingerprintForType(type.rawType, alreadySeen, hasher)) { orig, paramType -> fingerprintForType(paramType, alreadySeen, orig) }
+ type.actualTypeArguments.fold(fingerprintForType(type.rawType, alreadySeen, hasher, factory)) { orig, paramType -> fingerprintForType(paramType, alreadySeen, orig, factory) }
} else if (type is GenericArrayType) {
// Hash the element type + some array hash
- fingerprintForType(type.genericComponentType, alreadySeen, hasher).putUnencodedChars(ARRAY_HASH)
+ fingerprintForType(type.genericComponentType, alreadySeen, hasher, factory).putUnencodedChars(ARRAY_HASH)
} else {
throw NotSerializableException("Don't know how to hash $type")
}
diff --git a/core/src/main/kotlin/net/corda/core/serialization/amqp/SerializationHelper.kt b/core/src/main/kotlin/net/corda/core/serialization/amqp/SerializationHelper.kt
index 107769cde7..85082544a4 100644
--- a/core/src/main/kotlin/net/corda/core/serialization/amqp/SerializationHelper.kt
+++ b/core/src/main/kotlin/net/corda/core/serialization/amqp/SerializationHelper.kt
@@ -1,14 +1,16 @@
package net.corda.core.serialization.amqp
+import com.google.common.reflect.TypeToken
import org.apache.qpid.proton.codec.Data
import java.beans.Introspector
-import java.beans.PropertyDescriptor
import java.io.NotSerializableException
+import java.lang.reflect.Method
import java.lang.reflect.Modifier
import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type
import kotlin.reflect.KClass
import kotlin.reflect.KFunction
+import kotlin.reflect.KParameter
import kotlin.reflect.full.findAnnotation
import kotlin.reflect.full.primaryConstructor
import kotlin.reflect.jvm.javaType
@@ -58,24 +60,26 @@ internal fun constructorForDeserialization(clazz: Class): KFunction
* Note, you will need any Java classes to be compiled with the `-parameters` option to ensure constructor parameters have
* names accessible via reflection.
*/
-internal fun propertiesForSerialization(kotlinConstructor: KFunction?, clazz: Class<*>): Collection {
- return if (kotlinConstructor != null) propertiesForSerialization(kotlinConstructor) else propertiesForSerialization(clazz)
+internal fun propertiesForSerialization(kotlinConstructor: KFunction?, clazz: Class<*>, factory: SerializerFactory): Collection {
+ return if (kotlinConstructor != null) propertiesForSerialization(kotlinConstructor, factory) else propertiesForSerialization(clazz, factory)
}
private fun isConcrete(clazz: Class<*>): Boolean = !(clazz.isInterface || Modifier.isAbstract(clazz.modifiers))
-private fun propertiesForSerialization(kotlinConstructor: KFunction): Collection {
+private fun propertiesForSerialization(kotlinConstructor: KFunction, factory: SerializerFactory): Collection {
val clazz = (kotlinConstructor.returnType.classifier as KClass<*>).javaObjectType
// Kotlin reflection doesn't work with Java getters the way you might expect, so we drop back to good ol' beans.
- val properties: Map = Introspector.getBeanInfo(clazz).propertyDescriptors.filter { it.name != "class" }.groupBy { it.name }.mapValues { it.value[0] }
+ val properties = Introspector.getBeanInfo(clazz).propertyDescriptors.filter { it.name != "class" }.groupBy { it.name }.mapValues { it.value[0] }
val rc: MutableList = ArrayList(kotlinConstructor.parameters.size)
for (param in kotlinConstructor.parameters) {
val name = param.name ?: throw NotSerializableException("Constructor parameter of $clazz has no name.")
- val matchingProperty = properties[name] ?: throw NotSerializableException("No property matching constructor parameter named $name of $clazz. If using Java, check that you have the -parameters option specified in the Java compiler.")
+ val matchingProperty = properties[name] ?: throw NotSerializableException("No property matching constructor parameter named $name of $clazz." +
+ " If using Java, check that you have the -parameters option specified in the Java compiler.")
// Check that the method has a getter in java.
- val getter = matchingProperty.readMethod ?: throw NotSerializableException("Property has no getter method for $name of $clazz. If using Java and the parameter name looks anonymous, check that you have the -parameters option specified in the Java compiler.")
- if (getter.genericReturnType == param.type.javaType) {
- rc += PropertySerializer.make(name, getter)
+ val getter = matchingProperty.readMethod ?: throw NotSerializableException("Property has no getter method for $name of $clazz." +
+ " If using Java and the parameter name looks anonymous, check that you have the -parameters option specified in the Java compiler.")
+ if (constructorParamTakesReturnTypeOfGetter(getter, param)) {
+ rc += PropertySerializer.make(name, getter, factory)
} else {
throw NotSerializableException("Property type ${getter.genericReturnType} for $name of $clazz differs from constructor parameter type ${param.type.javaType}")
}
@@ -83,14 +87,16 @@ private fun propertiesForSerialization(kotlinConstructor: KFunction
return rc
}
-private fun propertiesForSerialization(clazz: Class<*>): Collection