private SerializerAdapter registerFromSuperType(final Class type, final Class superType) {
final SerializerAdapter serializer = typeMap.get(superType);
if (serializer != null) {
safeRegister(type, serializer);
}
return serializer;
}
public void register(Class type, Serializer serializer) {
if (type == null) {
throw new IllegalArgumentException("Class type information is required!");
}
if (serializer.getTypeId() <= 0) {
throw new IllegalArgumentException(
"Type id must be positive! Current: "
+ serializer.getTypeId()
+ ", Serializer: "
+ serializer);
}
safeRegister(type, createSerializerAdapter(serializer));
}
public SerializerAdapter serializerFor(final Class type) {
if (DataSerializable.class.isAssignableFrom(type)) {
return dataSerializerAdapter;
} else if (Portable.class.isAssignableFrom(type)) {
return portableSerializerAdapter;
} else {
final SerializerAdapter serializer;
if ((serializer = constantTypesMap.get(type)) != null) {
return serializer;
}
}
SerializerAdapter serializer = typeMap.get(type);
if (serializer == null) {
// look for super classes
Class typeSuperclass = type.getSuperclass();
final Set<Class> interfaces = new LinkedHashSet<Class>(5);
getInterfaces(type, interfaces);
while (typeSuperclass != null) {
if ((serializer = registerFromSuperType(type, typeSuperclass)) != null) {
break;
}
getInterfaces(typeSuperclass, interfaces);
typeSuperclass = typeSuperclass.getSuperclass();
}
if (serializer == null) {
// look for interfaces
for (Class typeInterface : interfaces) {
if ((serializer = registerFromSuperType(type, typeInterface)) != null) {
break;
}
}
}
if (serializer == null && (serializer = global.get()) != null) {
safeRegister(type, serializer);
}
}
return serializer;
}
SerializationServiceImpl(
InputOutputFactory inputOutputFactory,
int version,
ClassLoader classLoader,
Map<Integer, ? extends DataSerializableFactory> dataSerializableFactories,
Map<Integer, ? extends PortableFactory> portableFactories,
Collection<ClassDefinition> classDefinitions,
boolean checkClassDefErrors,
ManagedContext managedContext,
PartitioningStrategy partitionStrategy,
int initialOutputBufferSize,
boolean enableCompression,
boolean enableSharedObject) {
this.inputOutputFactory = inputOutputFactory;
this.classLoader = classLoader;
this.managedContext = managedContext;
this.globalPartitioningStrategy = partitionStrategy;
this.outputBufferSize = initialOutputBufferSize;
PortableHookLoader loader = new PortableHookLoader(portableFactories, classLoader);
serializationContext =
new SerializationContextImpl(this, loader.getFactories().keySet(), version);
for (ClassDefinition cd : loader.getDefinitions()) {
serializationContext.registerClassDefinition(cd);
}
dataSerializerAdapter =
new StreamSerializerAdapter(
this, new DataSerializer(dataSerializableFactories, classLoader));
portableSerializer = new PortableSerializer(serializationContext, loader.getFactories());
portableSerializerAdapter = new StreamSerializerAdapter(this, portableSerializer);
registerConstant(DataSerializable.class, dataSerializerAdapter);
registerConstant(Portable.class, portableSerializerAdapter);
registerConstant(Byte.class, new ByteSerializer());
registerConstant(Boolean.class, new BooleanSerializer());
registerConstant(Character.class, new CharSerializer());
registerConstant(Short.class, new ShortSerializer());
registerConstant(Integer.class, new IntegerSerializer());
registerConstant(Long.class, new LongSerializer());
registerConstant(Float.class, new FloatSerializer());
registerConstant(Double.class, new DoubleSerializer());
registerConstant(byte[].class, new TheByteArraySerializer());
registerConstant(char[].class, new CharArraySerializer());
registerConstant(short[].class, new ShortArraySerializer());
registerConstant(int[].class, new IntegerArraySerializer());
registerConstant(long[].class, new LongArraySerializer());
registerConstant(float[].class, new FloatArraySerializer());
registerConstant(double[].class, new DoubleArraySerializer());
registerConstant(String.class, new StringSerializer());
safeRegister(Date.class, new DateSerializer());
safeRegister(BigInteger.class, new BigIntegerSerializer());
safeRegister(BigDecimal.class, new BigDecimalSerializer());
safeRegister(Externalizable.class, new Externalizer(enableCompression));
safeRegister(Serializable.class, new ObjectSerializer(enableSharedObject, enableCompression));
safeRegister(Class.class, new ClassSerializer());
safeRegister(Enum.class, new EnumSerializer());
registerClassDefinitions(classDefinitions, checkClassDefErrors);
}
void safeRegister(final Class type, final Serializer serializer) {
safeRegister(type, createSerializerAdapter(serializer));
}
