public <T> T toObject(final Object object) { if (!(object instanceof Data)) { return (T) object; } Data data = (Data) object; if (data.bufferSize() == 0 && data.isDataSerializable()) { return null; } try { final int typeId = data.type; final SerializerAdapter serializer = serializerFor(typeId); if (serializer == null) { if (active) { throw new HazelcastSerializationException( "There is no suitable de-serializer for type " + typeId); } throw new HazelcastInstanceNotActiveException(); } if (typeId == SerializationConstants.CONSTANT_TYPE_PORTABLE) { serializationContext.registerClassDefinition(data.classDefinition); } Object obj = serializer.read(data); if (managedContext != null) { obj = managedContext.initialize(obj); } return (T) obj; } catch (Throwable e) { handleException(e); } return null; }
public Object readObject(final ObjectDataInput in) { try { final boolean isNull = in.readBoolean(); if (isNull) { return null; } final int typeId = in.readInt(); final SerializerAdapter serializer = serializerFor(typeId); if (serializer == null) { if (active) { throw new HazelcastSerializationException( "There is no suitable de-serializer for type " + typeId); } throw new HazelcastInstanceNotActiveException(); } if (typeId == SerializationConstants.CONSTANT_TYPE_PORTABLE && in instanceof PortableContextAwareInputStream) { ClassDefinition classDefinition = new ClassDefinitionImpl(); classDefinition.readData(in); classDefinition = serializationContext.registerClassDefinition(classDefinition); PortableContextAwareInputStream ctxIn = (PortableContextAwareInputStream) in; ctxIn.setClassDefinition(classDefinition); } Object obj = serializer.read(in); if (managedContext != null) { obj = managedContext.initialize(obj); } return obj; } catch (Throwable e) { handleException(e); } return null; }
private void registerClassDefinition( ClassDefinition cd, Map<Integer, ClassDefinition> classDefMap, boolean checkClassDefErrors) { for (int i = 0; i < cd.getFieldCount(); i++) { FieldDefinition fd = cd.get(i); if (fd.getType() == FieldType.PORTABLE || fd.getType() == FieldType.PORTABLE_ARRAY) { int classId = fd.getClassId(); ClassDefinition nestedCd = classDefMap.get(classId); if (nestedCd != null) { ((ClassDefinitionImpl) cd).addClassDef(nestedCd); registerClassDefinition(nestedCd, classDefMap, checkClassDefErrors); serializationContext.registerClassDefinition(nestedCd); } else if (checkClassDefErrors) { throw new HazelcastSerializationException( "Could not find registered ClassDefinition for class-id: " + classId); } } } serializationContext.registerClassDefinition(cd); }
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); }