Java 类com.esotericsoftware.kryo.Serializer 实例源码

public KryoTranscoderTests(final int bufferSize) {

        this.principalAttributes = new HashMap<String, Object>();
        this.principalAttributes.put(ST_ID, TGT_ID);

        transcoder = new KryoTranscoder(bufferSize);
        final Map<Class<?>, Serializer> serializerMap = new HashMap<Class<?>, Serializer>();
        serializerMap.put(
                MockServiceTicket.class,
                new FieldSerializer(transcoder.getKryo(), MockServiceTicket.class));
        serializerMap.put(
                MockTicketGrantingTicket.class,
                new FieldSerializer(transcoder.getKryo(), MockTicketGrantingTicket.class));
        serializerMap.put(
                TicketGrantingTicketImpl.class,
                new FieldSerializer(transcoder.getKryo(), TicketGrantingTicketImpl.class));
        serializerMap.put(
                ServiceTicketImpl.class,
                new FieldSerializer(transcoder.getKryo(), ServiceTicketImpl.class));
        transcoder.setSerializerMap(serializerMap);
        transcoder.initialize();
    }

@Override
public Queue read(Kryo kryo, Input input, Class<Queue> type) {
    int length = input.readVarInt(true);
    Registration registration = kryo.readClass(input);
    Class cls = registration == null ? Object.class : registration.getType();
    Queue queue = new Queue(length, cls);
    kryo.reference(queue);
    Class elementClass = null;
    Serializer serializer = null;
    if (genericType != null) {
        elementClass = genericType;
        serializer = kryo.getSerializer(genericType);
        genericType = null;
    }
    if (serializer != null) {
        for (int i = 0; i < length; i++)
            queue.addLast(kryo.readObjectOrNull(input, elementClass, serializer));
    } else {
        for (int i = 0; i < length; i++)
            queue.addLast(kryo.readClassAndObject(input));
    }
    return queue;
}

public void write (Kryo kryo, Output output, ObjectFloatMap map) {
    int length = map.size;
    output.writeVarInt(length, true);
    output.writeBoolean(false); // whether type is written (in case future version of ObjectFloatMap supports type awareness)

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyGenericType);
        keyGenericType = null;
    }

    for (Iterator iter = map.iterator(); iter.hasNext();) {
        ObjectFloatMap.Entry entry = (ObjectFloatMap.Entry)iter.next();
        if (keySerializer != null) {
            kryo.writeObject(output, entry.key, keySerializer);
        } else
            kryo.writeClassAndObject(output, entry.key);
        output.writeFloat(entry.value);
    }
}

@Override
public void write(Kryo kryo, Output output, SortedIntList list) {
    output.writeVarInt(list.size(), true);
    Serializer serializer = null;
    if (genericType != null) {
        if (serializer == null) serializer = kryo.getSerializer(genericType);
        genericType = null;
    }
    for (Iterator<SortedIntList.Node> iter = list.iterator(); iter.hasNext();){
        SortedIntList.Node node = iter.next();
        output.writeInt(node.index);
        if (serializer != null) {
            kryo.writeObjectOrNull(output, node.value, serializer);
        } else {
            kryo.writeClassAndObject(output, node.value);
        }
    }
}

@Override
public SortedIntList read(Kryo kryo, Input input, Class<SortedIntList> type) {
    int length = input.readVarInt(true);
    SortedIntList list = new SortedIntList();
    kryo.reference(list);
    Class elementClass = null;
    Serializer serializer = null;
    if (genericType != null) {
        elementClass = genericType;
        serializer = kryo.getSerializer(genericType);
        genericType = null;
    }
    for (int i = 0; i < length; i++) {
        int index = input.readInt();
        Object value = serializer != null ?
                kryo.readObjectOrNull(input, elementClass, serializer) : kryo.readClassAndObject(input);
        list.insert(index, value);
    }
    return list;
}

@Override
public T read(Kryo kryo, Input input, Class<T> type) {
    int length = input.readVarInt(true);
    boolean ordered = input.readBoolean();
    Class cls = kryo.readClass(input).getType();
    T array = create(ordered, length, cls);
    kryo.reference(array);
    Class elementClass = null;
    Serializer serializer = null;
    if (genericType != null) {
        elementClass = genericType;
        serializer = kryo.getSerializer(genericType);
        genericType = null;
    }
    if (serializer != null) {
        for (int i = 0; i < length; i++)
            array.add(kryo.readObjectOrNull(input, elementClass, serializer));
    } else {
        for (int i = 0; i < length; i++)
            array.add(kryo.readClassAndObject(input));
    }
    return array;
}

@Override
public T read(Kryo kryo, Input input, Class<T> type) {
    int length = input.readVarInt(true);
    input.readBoolean(); // currently unused
    T objectSet = create(length);

    kryo.reference(objectSet);

    Class elementClass = null;
    Serializer serializer = null;
    if (genericType != null) {
        elementClass = genericType;
        serializer = kryo.getSerializer(genericType);
        genericType = null;
    }
    if (serializer != null) {
        for (int i = 0; i < length; i++)
            objectSet.add(kryo.readObject(input, elementClass, serializer));
    } else {
        for (int i = 0; i < length; i++)
            objectSet.add(kryo.readClassAndObject(input));
    }
    return objectSet;
}

public void write (Kryo kryo, Output output, LongMap map) {
    int length = map.size;
    output.writeVarInt(length, true);
    output.writeBoolean(false); // whether type is written (in case future version of LongMap supports type awareness)

    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueGenericType);
        valueGenericType = null;
    }

    for (Iterator iter = map.iterator(); iter.hasNext();) {
        LongMap.Entry entry = (LongMap.Entry)iter.next();
        output.writeLong(entry.key);
        if (valueSerializer != null) {
            kryo.writeObjectOrNull(output, entry.value, valueSerializer);
        } else
            kryo.writeClassAndObject(output, entry.value);
    }
}

public void write (Kryo kryo, Output output, IntMap map) {
    int length = map.size;
    output.writeVarInt(length, true);
    output.writeBoolean(false); // whether type is written (in case future version of IntMap supports type awareness)
    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueGenericType);
        valueGenericType = null;
    }

    for (Iterator iter = map.iterator(); iter.hasNext();) {
        IntMap.Entry entry = (IntMap.Entry)iter.next();
        output.writeInt(entry.key);
        if (valueSerializer != null) {
            kryo.writeObjectOrNull(output, entry.value, valueSerializer);
        } else
            kryo.writeClassAndObject(output, entry.value);
    }
}

public void write (Kryo kryo, Output output, ObjectIntMap map) {
    int length = map.size;
    output.writeVarInt(length, true);
    output.writeBoolean(false); // whether type is written (in case future version of ObjectIntMap supports type awareness)

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyGenericType);
        keyGenericType = null;
    }

    for (Iterator iter = map.iterator(); iter.hasNext();) {
        ObjectIntMap.Entry entry = (ObjectIntMap.Entry)iter.next();
        if (keySerializer != null) {
            kryo.writeObject(output, entry.key, keySerializer);
        } else
            kryo.writeClassAndObject(output, entry.key);
        output.writeInt(entry.value);
    }
}

/**
 * Creates a Kryo instance.
 *
 * @return Kryo instance
 */
@Override
public Kryo create() {
    log.trace("Creating Kryo instance for {}", this);
    Kryo kryo = new Kryo();
    kryo.setRegistrationRequired(registrationRequired);

    // TODO rethink whether we want to use StdInstantiatorStrategy
    kryo.setInstantiatorStrategy(
            new Kryo.DefaultInstantiatorStrategy(new StdInstantiatorStrategy()));

    for (RegistrationBlock block : registeredBlocks) {
        int id = block.begin();
        if (id == FLOATING_ID) {
            id = kryo.getNextRegistrationId();
        }
        for (Pair<Class<?>, Serializer<?>> entry : block.types()) {
            register(kryo, entry.getLeft(), entry.getRight(), id++);
        }
    }
    return kryo;
}

private Kryo createKryo() {
    Kryo result = new KryoReflectionFactorySupport() {

        @Override
        public Serializer<?> getDefaultSerializer(@SuppressWarnings("rawtypes") final Class clazz) {
            if (EnumMap.class.isAssignableFrom(clazz)) {
                return new EnumMapSerializer();
            }
            if (SubListSerializers.ArrayListSubListSerializer.canSerialize(clazz) || SubListSerializers.JavaUtilSubListSerializer.canSerialize(clazz)) {
                return SubListSerializers.createFor(clazz);
            }
            return super.getDefaultSerializer(clazz);
        }
    };
    result.register(Collections.singletonList("").getClass(), new ArraysAsListSerializer());
    UnmodifiableCollectionsSerializer.registerSerializers(result);
    return result;
}

/**
 * Set union, the set with the same key will be reduced(union) together in the root process.
 * @param mapData map set data
 * @param rootRank root rank
 * @param elementSerializer element object Kryo serializer
 * @param elementType element obejct class

 * @return if this process is root, the set with the same key will be reduced together,
 *         otherwise, invalid map or null is returned.
 * @throws Mp4jException
 */
public <T> Map<String, Set<T>> reduceMapSetUnion(Map<String, Set<T>> mapData, int rootRank, Serializer<T> elementSerializer, Class<T> elementType) throws Mp4jException {

    Operand operand = Operands.OBJECT_OPERAND(new Mp4jSetSerializer<>(elementSerializer, elementType), elementType);
    IOperator operator = new IObjectOperator<Set<T>>() {
        @Override
        public Set<T> apply(Set<T> o1, Set<T> o2) {
            for (T val : o2) {
                o1.add(val);
            }
            return o1;
        }
    };

    return reduceMap(mapData, operand, operator, rootRank);

}

/**
 * Set union, the set with the same key will be reduced(union) together.
 * @param mapData map set data
 * @param elementSerializer element object Kryo serializer
 * @param elementType element object class

 * @return the set with the same key will be reduced together.
 * @throws Mp4jException
 */
public <T> Map<String, Set<T>> allreduceMapSetUnion(Map<String, Set<T>> mapData, Serializer<T> elementSerializer, Class<T> elementType) throws Mp4jException {

    Operand operand = Operands.OBJECT_OPERAND(new Mp4jSetSerializer<>(elementSerializer, elementType), elementType);
    IOperator operator = new IObjectOperator<Set<T>>() {
        @Override
        public Set<T> apply(Set<T> o1, Set<T> o2) {
            for (T val : o2) {
                o1.add(val);
            }
            return o1;
        }
    };

    return allreduceMap(mapData, operand, operator);

}

/**
 * Set union, the set with the same key will be reduced(union) together in the root process and thread.
 * @param mapData map set data
 * @param rootRank root rank
 * @param elementSerializer element object Kryo serializer
 * @param elementType element object class

 * @return if this process and thread is root, the set with the same key will be reduced together,
 *         otherwise, invalid map or null is returned.
 * @throws Mp4jException
 */
public <T> Map<String, Set<T>> reduceMapSetUnion(Map<String, Set<T>> mapData, int rootRank, int rootThreadId, Serializer<T> elementSerializer, Class<T> elementType) throws Mp4jException {

    Operand operand = Operands.OBJECT_OPERAND(new ProcessCommSlave.Mp4jSetSerializer<>(elementSerializer, elementType), elementType);
    IOperator operator = new IObjectOperator<Set<T>>() {
        @Override
        public Set<T> apply(Set<T> o1, Set<T> o2) {
            for (T val : o2) {
                o1.add(val);
            }
            return o1;
        }
    };

    return reduceMap(mapData, operand, operator, rootRank, rootThreadId);

}

/**
 * Set union, the set with the same key will be reduced(union) together.
 * @param mapData map set data
 * @param elementSerializer element object Kryo serializer
 * @param elementType element object class

 * @return the set with the same key will be reduced together.
 * @throws Mp4jException
 */
public <T> Map<String, Set<T>> allreduceMapSetUnion(Map<String, Set<T>> mapData, Serializer<T> elementSerializer, Class<T> elementType) throws Mp4jException {

    Operand operand = Operands.OBJECT_OPERAND(new ProcessCommSlave.Mp4jSetSerializer<>(elementSerializer, elementType), elementType);
    IOperator operator = new IObjectOperator<Set<T>>() {
        @Override
        public Set<T> apply(Set<T> o1, Set<T> o2) {
            for (T val : o2) {
                o1.add(val);
            }
            return o1;
        }
    };

    return allreduceMap(mapData, operand, operator);

}

public KryoTranscoderTests() {
    transcoder = new KryoTranscoder();
    final Map<Class<?>, Serializer> serializerMap = new HashMap<Class<?>, Serializer>();
    serializerMap.put(
            MockServiceTicket.class,
            new FieldSerializer(transcoder.getKryo(), MockServiceTicket.class));
    serializerMap.put(
            MockTicketGrantingTicket.class,
            new FieldSerializer(transcoder.getKryo(), MockTicketGrantingTicket.class));
    transcoder.setSerializerMap(serializerMap);
    transcoder.initialize();

    this.principalAttributes = new HashMap<>();
    this.principalAttributes.put(NICKNAME_KEY, NICKNAME_VALUE);
}

public KryoTranscoderTests() {
    transcoder = new KryoTranscoder();
    final Map<Class<?>, Serializer> serializerMap = new HashMap<Class<?>, Serializer>();
    serializerMap.put(
            MockServiceTicket.class,
            new FieldSerializer(transcoder.getKryo(), MockServiceTicket.class));
    serializerMap.put(
            MockTicketGrantingTicket.class,
            new FieldSerializer(transcoder.getKryo(), MockTicketGrantingTicket.class));
    transcoder.setSerializerMap(serializerMap);
    transcoder.initialize();

    this.principalAttributes = new HashMap<>();
    this.principalAttributes.put(NICKNAME_KEY, NICKNAME_VALUE);
}

public KryoTranscoderTests() {
    transcoder = new KryoTranscoder();
    final Map<Class<?>, Serializer> serializerMap = new HashMap<>();
    serializerMap.put(
            MockServiceTicket.class,
            new FieldSerializer(transcoder.getKryo(), MockServiceTicket.class));
    serializerMap.put(
            MockTicketGrantingTicket.class,
            new FieldSerializer(transcoder.getKryo(), MockTicketGrantingTicket.class));
    transcoder.setSerializerMap(serializerMap);
    transcoder.initialize();

    this.principalAttributes = new HashMap<>();
    this.principalAttributes.put(NICKNAME_KEY, NICKNAME_VALUE);
}

@Override
public Serializer getDefaultSerializer(Class type) {
    if (type == null) {
        throw new IllegalArgumentException("type cannot be null.");
    }

    if (!type.isArray() && !ReflectionUtils.checkZeroArgConstructor(type)) {
        if (logger.isWarnEnabled()) {
            logger.warn(type + " has no zero-arg constructor and this will affect the serialization performance");
        }
        return new JavaSerializer();
    }
    return super.getDefaultSerializer(type);
}

/**
 * Fluent-style version of {@link #setSerializers(Map)}.
 *
 * @param type Type.
 * @param serializer Type serializer.
 *
 * @return This instance.
 */
public KryoCodecFactory<T> withSerializer(Class<?> type, Serializer<?> serializer) {
    if (serializers == null) {
        serializers = new HashMap<>();
    }

    serializers.put(type, serializer);

    return this;
}

/**
 * Fluent style version of {@link #setDefaultSerializers(Map)}.
 *
 * @param type Type to serialize.
 * @param serializer Serializer.
 * @param <V> Type to serialize.
 *
 * @return This instance.
 */
public <V> KryoCodecFactory<T> withDefaultSerializer(Class<V> type, Serializer<V> serializer) {
    if (defaultSerializers == null) {
        defaultSerializers = new HashMap<>();
    }

    defaultSerializers.put(type, serializer);

    return this;
}

public KryoTranscoderTests() {
    transcoder = new KryoTranscoder();
    final Map<Class<?>, Serializer> serializerMap = new HashMap<Class<?>, Serializer>();
    serializerMap.put(
            MockServiceTicket.class,
            new FieldSerializer(transcoder.getKryo(), MockServiceTicket.class));
    serializerMap.put(
            MockTicketGrantingTicket.class,
            new FieldSerializer(transcoder.getKryo(), MockTicketGrantingTicket.class));
    transcoder.setSerializerMap(serializerMap);
    transcoder.initialize();

    this.principalAttributes = new HashMap<>();
    this.principalAttributes.put(NICKNAME_KEY, NICKNAME_VALUE);
}

public void write (Kryo kryo, Output output, T map) {
    int length = map.size;
    output.writeVarInt(length, true);
    output.writeBoolean(false); // whether type is written (in case future version of ObjectMap supports type awareness)

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyGenericType);
        keyGenericType = null;
    }
    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueGenericType);
        valueGenericType = null;
    }

    for (Iterator iter = map.iterator(); iter.hasNext();) {
        ObjectMap.Entry entry = (ObjectMap.Entry)iter.next();
        if (keySerializer != null) {
            kryo.writeObject(output, entry.key, keySerializer);
        } else
            kryo.writeClassAndObject(output, entry.key);
        if (valueSerializer != null) {
            kryo.writeObjectOrNull(output, entry.value, valueSerializer);
        } else
            kryo.writeClassAndObject(output, entry.value);
    }
}

public T read (Kryo kryo, Input input, Class<T> type) {
    int length = input.readVarInt(true);
    input.readBoolean(); // currently unused
    T map = create(length);

    Class keyClass = null;
    Class valueClass = null;

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        keyClass = keyGenericType;
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyClass);
        keyGenericType = null;
    }
    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        valueClass = valueGenericType;
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueClass);
        valueGenericType = null;
    }

    kryo.reference(map);

    for (int i = 0; i < length; i++) {
        Object key;
        if (keySerializer != null) {
            key = kryo.readObject(input, keyClass, keySerializer);
        } else
            key = kryo.readClassAndObject(input);
        Object value;
        if (valueSerializer != null) {
            value = kryo.readObjectOrNull(input, valueClass, valueSerializer);
        } else
            value = kryo.readClassAndObject(input);
        map.put(key, value);
    }
    return map;
}

public ObjectFloatMap read (Kryo kryo, Input input, Class<ObjectFloatMap> type) {
    int length = input.readVarInt(true);
    input.readBoolean(); // currently unused
    ObjectFloatMap map = create(length);

    Class keyClass = null;

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        keyClass = keyGenericType;
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyClass);
        keyGenericType = null;
    }

    kryo.reference(map);

    for (int i = 0; i < length; i++) {
        Object key;
        if (keySerializer != null) {
            key = kryo.readObject(input, keyClass, keySerializer);
        } else
            key = kryo.readClassAndObject(input);
        float value = input.readFloat();
        map.put(key, value);
    }
    return map;
}

public void write (Kryo kryo, Output output, ArrayMap map) {
    output.writeBoolean(map.ordered);
    int length = map.size;
    output.writeVarInt(length, true);
    kryo.writeClass(output, map.keys.getClass().getComponentType());
    kryo.writeClass(output, map.values.getClass().getComponentType());

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyGenericType);
        keyGenericType = null;
    }
    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueGenericType);
        valueGenericType = null;
    }

    for (Iterator iter = map.iterator(); iter.hasNext();) {
        ObjectMap.Entry entry = (ObjectMap.Entry)iter.next();
        if (keySerializer != null) {
            kryo.writeObject(output, entry.key, keySerializer);
        } else
            kryo.writeClassAndObject(output, entry.key);
        if (valueSerializer != null) {
            kryo.writeObjectOrNull(output, entry.value, valueSerializer);
        } else
            kryo.writeClassAndObject(output, entry.value);
    }
}

public void write (Kryo kryo, Output output, IdentityMap map) {
    int length = map.size;
    output.writeVarInt(length, true);
    output.writeBoolean(false); // whether type is written (in case future version of IdentityMap supports type awareness)

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyGenericType);
        keyGenericType = null;
    }
    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueGenericType);
        valueGenericType = null;
    }

    for (Iterator iter = map.iterator(); iter.hasNext();) {
        IdentityMap.Entry entry = (IdentityMap.Entry)iter.next();
        if (keySerializer != null) {
            kryo.writeObject(output, entry.key, keySerializer);
        } else
            kryo.writeClassAndObject(output, entry.key);
        if (valueSerializer != null) {
            kryo.writeObjectOrNull(output, entry.value, valueSerializer);
        } else
            kryo.writeClassAndObject(output, entry.value);
    }
}

public IdentityMap read (Kryo kryo, Input input, Class<IdentityMap> type) {
    int length = input.readVarInt(true);
    input.readBoolean(); // currently unused
    IdentityMap map = new IdentityMap(length);

    Class keyClass = null;
    Class valueClass = null;

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        keyClass = keyGenericType;
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyClass);
        keyGenericType = null;
    }
    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        valueClass = valueGenericType;
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueClass);
        valueGenericType = null;
    }

    kryo.reference(map);

    for (int i = 0; i < length; i++) {
        Object key;
        if (keySerializer != null) {
            key = kryo.readObject(input, keyClass, keySerializer);
        } else
            key = kryo.readClassAndObject(input);
        Object value;
        if (valueSerializer != null) {
            value = kryo.readObjectOrNull(input, valueClass, valueSerializer);
        } else
            value = kryo.readClassAndObject(input);
        map.put(key, value);
    }
    return map;
}

public LongMap read (Kryo kryo, Input input, Class<LongMap> type) {
    int length = input.readVarInt(true);
    input.readBoolean(); // currently unused
    LongMap map = new LongMap(length);

    Class valueClass = null;

    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        valueClass = valueGenericType;
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueClass);
        valueGenericType = null;
    }

    kryo.reference(map);

    for (int i = 0; i < length; i++) {
        long key = input.readLong();
        Object value;
        if (valueSerializer != null) {
            value = kryo.readObjectOrNull(input, valueClass, valueSerializer);
        } else
            value = kryo.readClassAndObject(input);
        map.put(key, value);
    }
    return map;
}

public IntMap read (Kryo kryo, Input input, Class<IntMap> type) {
    int length = input.readVarInt(true);
    input.readBoolean(); // currently unused
    IntMap map = new IntMap(length);

    Class valueClass = null;

    Serializer valueSerializer = null;
    if (valueGenericType != null) {
        valueClass = valueGenericType;
        if (valueSerializer == null) valueSerializer = kryo.getSerializer(valueClass);
        valueGenericType = null;
    }

    kryo.reference(map);

    for (int i = 0; i < length; i++) {
        int key = input.readInt();
        Object value;
        if (valueSerializer != null) {
            value = kryo.readObjectOrNull(input, valueClass, valueSerializer);
        } else
            value = kryo.readClassAndObject(input);
        map.put(key, value);
    }
    return map;
}

public ObjectIntMap read (Kryo kryo, Input input, Class<ObjectIntMap> type) {
    int length = input.readVarInt(true);
    input.readBoolean(); // currently unused
    ObjectIntMap map = create(length);

    Class keyClass = null;

    Serializer keySerializer = null;
    if (keyGenericType != null) {
        keyClass = keyGenericType;
        if (keySerializer == null) keySerializer = kryo.getSerializer(keyClass);
        keyGenericType = null;
    }

    kryo.reference(map);

    for (int i = 0; i < length; i++) {
        Object key;
        if (keySerializer != null) {
            key = kryo.readObject(input, keyClass, keySerializer);
        } else
            key = kryo.readClassAndObject(input);
        int value = input.readInt();
        map.put(key, value);
    }
    return map;
}

/** Convenience method for retriving the ColorSerializer if it has already been registered with Kryo.
 * @return The ColorSerializer registered for {@link Color}, or null if none has been registered or the registered
 * serializer is not a {@link ColorSerializer}.
 */
public static ColorSerializer getColorSerializer (Kryo kryo){
    Serializer serializer = kryo.getSerializer(Color.class);
    if (serializer != null && serializer instanceof ColorSerializer)
        return (ColorSerializer)serializer;
    return null;
}

/** Convenience method for retriving the PixmapSerializer if it has already been registered with Kryo.
 * @return The PixmapSerializer registered for {@link Pixmap}, or null if none has been registered or the registered
 * serializer is not a {@link PixmapSerializer}.
 */
public static PixmapSerializer getPixmapSerializer (Kryo kryo){
    Serializer serializer = kryo.getSerializer(Pixmap.class);
    if (serializer != null && serializer instanceof PixmapSerializer)
        return (PixmapSerializer)serializer;
    return null;
}

/** Reads an object using the specified serializer, but does not return it. If the object type is a {@link Disposable},
 * uses native memory, or is time consuming to instantiate, it should use an implementation of {@link SkippableSerializer}
 * to avoid memory leaks or wasted instantiation time. */
public static <T> void skipObsoleteObject (Kryo kryo, Input input, Class<T> type, Serializer serializer){
    com.esotericsoftware.kryo.util.ObjectMap graphContext = kryo.getGraphContext();
    final int branchDepth = graphContext.containsKey(OBSOLETE_BRANCH_KEY) ? (Integer)graphContext.get(OBSOLETE_BRANCH_KEY) : 0;
    graphContext.put(OBSOLETE_BRANCH_KEY, branchDepth + 1);

    kryo.readObject(input, type, serializer);

    graphContext.put(OBSOLETE_BRANCH_KEY, branchDepth);
}

/** Reads an object or null using the specified serializer, but does not return it. If the object type is a {@link Disposable},
 * uses native memory, or is time consuming to instantiate, it should use an implementation of {@link SkippableSerializer}
 * to avoid memory leaks or wasted instantiation time. */
public static <T> void skipObsoleteObjectOrNull (Kryo kryo, Input input, Class<T> type, Serializer serializer){
    com.esotericsoftware.kryo.util.ObjectMap graphContext = kryo.getGraphContext();
    final int branchDepth = graphContext.containsKey(OBSOLETE_BRANCH_KEY) ? (Integer)graphContext.get(OBSOLETE_BRANCH_KEY) : 0;
    graphContext.put(OBSOLETE_BRANCH_KEY, branchDepth + 1);

    kryo.readObjectOrNull(input, type, serializer);

    graphContext.put(OBSOLETE_BRANCH_KEY, branchDepth);
}

@Override
public Serializer getDefaultSerializer(Class type) {
    if (type == null) {
        throw new IllegalArgumentException("type cannot be null.");
    }

    if (!type.isArray() && !ReflectionUtils.checkZeroArgConstructor(type)) {
        if (logger.isWarnEnabled()) {
            logger.warn(type + " has no zero-arg constructor and this will affect the serialization performance");
        }
        return new JavaSerializer();
    }
    return super.getDefaultSerializer(type);
}

/**
 * Register {@code type} and {@code serializer} to {@code kryo} instance.
 *
 * @param kryo       Kryo instance
 * @param type       type to register
 * @param serializer Specific serializer to register or null to use default.
 * @param id         type registration id to use
 */
private void register(Kryo kryo, Class<?> type, Serializer<?> serializer, int id) {
    Registration existing = kryo.getRegistration(id);
    if (existing != null) {
        if (existing.getType() != type) {
            log.error("{}: Failed to register {} as {}, {} was already registered.",
                      friendlyName(), type, id, existing.getType());

            throw new IllegalStateException(String.format(
                      "Failed to register %s as %s, %s was already registered.",
                      type, id, existing.getType()));
        }
        // falling through to register call for now.
        // Consider skipping, if there's reasonable
        // way to compare serializer equivalence.
    }
    Registration r;
    if (serializer == null) {
        r = kryo.register(type, id);
    } else {
        r = kryo.register(type, serializer, id);
    }
    if (r.getId() != id) {
        log.warn("{}: {} already registed as {}. Skipping {}.",
                 friendlyName(), r.getType(), r.getId(), id);
    }
    log.trace("{} registered as {}", r.getType(), r.getId());
}

public Mp4jObjectMapReduceSerializer(MapMetaData<T> mapMetaData,
                                     IObjectOperator<T> operator,
                                     Serializer<T> serializer,
                                     Class<T> type
                                     ) {
    this.setAcceptsNull(true);
    this.mapMetaData = mapMetaData;
    this.operator = operator;
    this.serializer = serializer;
    this.type = type;
}

/**
 * Set union
 * @param setData set data
 * @param rootRank root rank
 * @param elementSerializer element object Kryo serializer
 * @param elementType element object class

 * @return if this process is root, set unison is returned,
 *         otherwise invalid set or null is returned.
 * @throws Mp4jException
 */
public <T> Set<T> reduceSetUnion(Set<T> setData, int rootRank, Serializer<T> elementSerializer, Class<T> elementType) throws Mp4jException {
    Map<String, Set<T>> mapTemp = new HashMap<>(1);
    mapTemp.put("key", setData);

    Map<String, Set<T>> mapReturn = reduceMapSetUnion(mapTemp, rootRank, elementSerializer, elementType);
    if (mapReturn != null) {
        return mapReturn.get("key");
    } else {
        return null;
    }
}