コード例 #1
0
 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;
 }
コード例 #2
0
 public void writeObject(final ObjectDataOutput out, final Object obj) {
   final boolean isNull = obj == null;
   try {
     out.writeBoolean(isNull);
     if (isNull) {
       return;
     }
     final SerializerAdapter serializer = serializerFor(obj.getClass());
     if (serializer == null) {
       if (active) {
         throw new HazelcastSerializationException(
             "There is no suitable serializer for " + obj.getClass());
       }
       throw new HazelcastInstanceNotActiveException();
     }
     out.writeInt(serializer.getTypeId());
     if (obj instanceof Portable) {
       final Portable portable = (Portable) obj;
       ClassDefinition classDefinition =
           serializationContext.lookupOrRegisterClassDefinition(portable);
       classDefinition.writeData(out);
     }
     serializer.write(out, obj);
   } catch (Throwable e) {
     handleException(e);
   }
 }
コード例 #3
0
  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;
  }
コード例 #4
0
 public void destroy() {
   active = false;
   for (SerializerAdapter serializer : typeMap.values()) {
     serializer.destroy();
   }
   typeMap.clear();
   idMap.clear();
   global.set(null);
   constantTypesMap.clear();
   for (BufferObjectDataOutput output : outputPool) {
     IOUtil.closeResource(output);
   }
   outputPool.clear();
 }
コード例 #5
0
 public void registerGlobal(final Serializer serializer) {
   SerializerAdapter adapter = createSerializerAdapter(serializer);
   if (!global.compareAndSet(null, adapter)) {
     throw new IllegalStateException("Global serializer is already registered!");
   }
   SerializerAdapter current = idMap.putIfAbsent(serializer.getTypeId(), adapter);
   if (current != null && current.getImpl().getClass() != adapter.getImpl().getClass()) {
     global.compareAndSet(adapter, null);
     throw new IllegalStateException(
         "Serializer ["
             + current.getImpl()
             + "] has been already registered for type-id: "
             + serializer.getTypeId());
   }
 }
コード例 #6
0
 @SuppressWarnings("unchecked")
 public Data toData(Object obj, PartitioningStrategy strategy) {
   if (obj == null) {
     return null;
   }
   if (obj instanceof Data) {
     return (Data) obj;
   }
   try {
     final SerializerAdapter serializer = serializerFor(obj.getClass());
     if (serializer == null) {
       if (active) {
         throw new HazelcastSerializationException(
             "There is no suitable serializer for " + obj.getClass());
       }
       throw new HazelcastInstanceNotActiveException();
     }
     final byte[] bytes = serializer.write(obj);
     final Data data = new Data(serializer.getTypeId(), bytes);
     if (obj instanceof Portable) {
       final Portable portable = (Portable) obj;
       data.classDefinition =
           serializationContext.lookup(portable.getFactoryId(), portable.getClassId());
     }
     if (strategy == null) {
       strategy = globalPartitioningStrategy;
     }
     if (strategy != null) {
       Object pk = strategy.getPartitionKey(obj);
       if (pk != null && pk != obj) {
         final Data partitionKey = toData(pk, EMPTY_PARTITIONING_STRATEGY);
         data.partitionHash = (partitionKey == null) ? -1 : partitionKey.getPartitionHash();
       }
     }
     return data;
   } catch (Throwable e) {
     handleException(e);
   }
   return null;
 }
コード例 #7
0
 private void safeRegister(final Class type, final SerializerAdapter serializer) {
   if (constantTypesMap.containsKey(type)) {
     throw new IllegalArgumentException("[" + type + "] serializer cannot be overridden!");
   }
   SerializerAdapter current = typeMap.putIfAbsent(type, serializer);
   if (current != null && current.getImpl().getClass() != serializer.getImpl().getClass()) {
     throw new IllegalStateException(
         "Serializer[" + current.getImpl() + "] has been already registered for type: " + type);
   }
   current = idMap.putIfAbsent(serializer.getTypeId(), serializer);
   if (current != null && current.getImpl().getClass() != serializer.getImpl().getClass()) {
     throw new IllegalStateException(
         "Serializer ["
             + current.getImpl()
             + "] has been already registered for type-id: "
             + serializer.getTypeId());
   }
 }
コード例 #8
0
 private void registerConstant(Class type, SerializerAdapter serializer) {
   constantTypesMap.put(type, serializer);
   constantTypeIds[indexForDefaultType(serializer.getTypeId())] = serializer;
 }