import com.esotericsoftware.kryo.pool.KryoCallback;
import com.esotericsoftware.kryo.pool.KryoFactory;
import com.esotericsoftware.kryo.pool.KryoPool;
-import com.esotericsoftware.kryo.serializers.CompatibleFieldSerializer;
import com.google.common.base.MoreObjects;
import com.google.common.collect.ImmutableList;
-import org.apache.commons.lang3.tuple.Pair;
import org.objenesis.strategy.StdInstantiatorStrategy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
import java.util.Objects;
import static java.util.Objects.requireNonNull;
*/
public static final int DEFAULT_BUFFER_SIZE = 4096;
- /**
- * Maximum allowed buffer size.
- */
- public static final int MAX_BUFFER_SIZE = 100 * 1000 * 1000;
-
/**
* ID to use if this KryoNamespace does not define registration id.
*/
- public static final int FLOATING_ID = -1;
+ private static final int FLOATING_ID = -1;
/**
* Smallest ID free to use for user defined registrations.
*/
- public static final int INITIAL_ID = 16;
+ private static final int INITIAL_ID = 16;
static final String NO_NAME = "(no name)";
private static final Logger LOGGER = LoggerFactory.getLogger(Namespace.class);
- /**
- * Default Kryo namespace.
- */
- public static final Namespace DEFAULT = builder().build();
-
- private final KryoPool kryoPool = new KryoPool.Builder(this)
- .softReferences()
- .build();
+ private final KryoPool kryoPool = new KryoPool.Builder(this).softReferences().build();
private final KryoOutputPool kryoOutputPool = new KryoOutputPool();
private final KryoInputPool kryoInputPool = new KryoInputPool();
private final ImmutableList<RegistrationBlock> registeredBlocks;
private final ClassLoader classLoader;
- private final boolean compatible;
private final boolean registrationRequired;
private final String friendlyName;
//@NotThreadSafe
public static final class Builder {
private int blockHeadId = INITIAL_ID;
- private List<Pair<Class<?>[], Serializer<?>>> types = new ArrayList<>();
+ private List<Entry<Class<?>[], Serializer<?>>> types = new ArrayList<>();
private List<RegistrationBlock> blocks = new ArrayList<>();
private ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
private boolean registrationRequired = true;
- private boolean compatible = false;
/**
* Builds a {@link Namespace} instance.
if (!types.isEmpty()) {
blocks.add(new RegistrationBlock(this.blockHeadId, types));
}
- return new Namespace(blocks, classLoader, registrationRequired, compatible, friendlyName).populate(1);
- }
-
- /**
- * Sets the next Kryo registration Id for following register entries.
- *
- * @param id Kryo registration Id
- * @return this
- * @see Kryo#register(Class, Serializer, int)
- */
- public Builder nextId(final int id) {
- if (!types.isEmpty()) {
- if (id != FLOATING_ID && id < blockHeadId + types.size()) {
-
- if (LOGGER.isWarnEnabled()) {
- LOGGER.warn("requested nextId {} could potentially overlap "
- + "with existing registrations {}+{} ",
- id, blockHeadId, types.size(), new RuntimeException());
- }
- }
- blocks.add(new RegistrationBlock(this.blockHeadId, types));
- types = new ArrayList<>();
- }
- this.blockHeadId = id;
- return this;
- }
-
- /**
- * Registers classes to be serialized using Kryo default serializer.
- *
- * @param expectedTypes list of classes
- * @return this
- */
- public Builder register(final Class<?>... expectedTypes) {
- for (Class<?> clazz : expectedTypes) {
- types.add(Pair.of(new Class<?>[]{clazz}, null));
- }
- return this;
+ return new Namespace(blocks, classLoader, registrationRequired, friendlyName).populate(1);
}
/**
* @return this
*/
public Builder register(Serializer<?> serializer, final Class<?>... classes) {
- types.add(Pair.of(classes, requireNonNull(serializer)));
+ types.add(Map.entry(classes, serializer));
return this;
}
return this;
}
- /**
- * Sets whether backwards/forwards compatible versioned serialization is enabled.
- * <p>
- * When compatible serialization is enabled, the {@link CompatibleFieldSerializer} will be set as the
- * default serializer for types that do not otherwise explicitly specify a serializer.
- *
- * @param compatible whether versioned serialization is enabled
- * @return this
- */
- public Builder setCompatible(boolean compatible) {
- this.compatible = compatible;
- return this;
- }
-
/**
* Sets the registrationRequired flag.
*
*
* @param registeredTypes types to register
* @param registrationRequired whether registration is required
- * @param compatible whether compatible serialization is enabled
* @param friendlyName friendly name for the namespace
*/
private Namespace(
final List<RegistrationBlock> registeredTypes,
ClassLoader classLoader,
boolean registrationRequired,
- boolean compatible,
String friendlyName) {
this.registeredBlocks = ImmutableList.copyOf(registeredTypes);
this.registrationRequired = registrationRequired;
this.classLoader = classLoader;
- this.compatible = compatible;
this.friendlyName = requireNonNull(friendlyName);
}
kryo.setClassLoader(classLoader);
kryo.setRegistrationRequired(registrationRequired);
- // If compatible serialization is enabled, override the default serializer.
- if (compatible) {
- kryo.setDefaultSerializer(CompatibleFieldSerializer::new);
- }
-
// TODO rethink whether we want to use StdInstantiatorStrategy
kryo.setInstantiatorStrategy(
new Kryo.DefaultInstantiatorStrategy(new StdInstantiatorStrategy()));
if (id == FLOATING_ID) {
id = kryo.getNextRegistrationId();
}
- for (Pair<Class<?>[], Serializer<?>> entry : block.types()) {
- register(kryo, entry.getLeft(), entry.getRight(), id++);
+ for (Entry<Class<?>[], Serializer<?>> entry : block.types()) {
+ register(kryo, entry.getKey(), entry.getValue(), id++);
}
}
return kryo;
static final class RegistrationBlock {
private final int begin;
- private final ImmutableList<Pair<Class<?>[], Serializer<?>>> types;
+ private final ImmutableList<Entry<Class<?>[], Serializer<?>>> types;
- RegistrationBlock(int begin, List<Pair<Class<?>[], Serializer<?>>> types) {
+ RegistrationBlock(int begin, List<Entry<Class<?>[], Serializer<?>>> types) {
this.begin = begin;
this.types = ImmutableList.copyOf(types);
}
return begin;
}
- public ImmutableList<Pair<Class<?>[], Serializer<?>>> types() {
+ public ImmutableList<Entry<Class<?>[], Serializer<?>>> types() {
return types;
}
Code Review / controller.git / blobdiff