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 Serializer<?> makeSerializer(Kryo kryo, Class<?> type) { if (type.isAnnotationPresent(Transient.class)) { LOGGER.info(type.getName(), " -> DummySerializer"); return new DummySerializer(); } LOGGER.info(type.getName(), " -> FieldSerializer"); checkDefaultConstructor(type); FieldSerializer<?> fieldSerializer = new FieldSerializer<>(kryo, type); fieldSerializer.setAcceptsNull(true); fieldSerializer.setCopyTransient(false); fieldSerializer.setFieldsCanBeNull(true); return fieldSerializer; }
@Override protected Kryo initialValue() { final Kryo kryo = new KryoReflectionFactorySupport() { @Override public Serializer<?> getDefaultSerializer(@SuppressWarnings("rawtypes") final Class clazz) { if (EnumSet.class.isAssignableFrom(clazz)) { return new EnumSetSerializer(); } if (EnumMap.class.isAssignableFrom(clazz)) { return new EnumMapSerializer(); } final Serializer<?> serializer = super.getDefaultSerializer(clazz); if (serializer instanceof FieldSerializer) { ((FieldSerializer<?>) serializer).setCopyTransient(false); } return serializer; } }; return kryo; }
public void testTransients() { kryo.register(HasTransients.class); HasTransients objectWithTransients1 = new HasTransients(); objectWithTransients1.transientField1 = "Test"; objectWithTransients1.anotherField2 = 5; objectWithTransients1.anotherField3 = "Field2"; FieldSerializer<HasTransients> ser = (FieldSerializer<HasTransients>) kryo .getSerializer(HasTransients.class); ser.setCopyTransient(false); HasTransients objectWithTransients3 = kryo.copy(objectWithTransients1); assertTrue( "Objects should be different if copy does not include transient fields", !objectWithTransients3.equals(objectWithTransients1)); assertEquals("transient fields should be null", objectWithTransients3.transientField1, null); ser.setCopyTransient(true); HasTransients objectWithTransients2 = kryo.copy(objectWithTransients1); assertEquals( "Objects should be equal if copy includes transient fields", objectWithTransients2, objectWithTransients1); }
final boolean isValidObject(final Object o) { if (o==null) return true; Boolean status = objectVerificationCache.getIfPresent(o.getClass()); if (status==null) { Kryo kryo = getKryo(); if (!(kryo.getSerializer(o.getClass()) instanceof FieldSerializer)) status=Boolean.TRUE; else if (!isValidClass(o.getClass())) status=Boolean.FALSE; else { try { Output out = new Output(128, maxOutputSize); kryo.writeClassAndObject(out,o); Input in = new Input(out.getBuffer(),0,out.position()); Object ocopy = kryo.readClassAndObject(in); status=(o.equals(ocopy)?Boolean.TRUE:Boolean.FALSE); } catch (Throwable e) { status=Boolean.FALSE; } } objectVerificationCache.put(o.getClass(),status); } return status; }
@Override public Node copy(Kryo kryo, Node original) { try { Object root = kryo.getContext().get("root"); if (root == null) { // original is the root kryo.getContext().put("root", original); root = original; } Serializer<Node> serializer = new FieldSerializer<>(kryo, original.getClass()); Node ret = serializer.copy(kryo, original); if (root == original) { // Register tree only from the root (should save some work) ParentRegistry.registerTree(ret); } return ret; } finally { kryo.getContext().remove("root"); } }
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 T read(final Kryo kryo, final Input input, final Class<T> type) { // do not use delegate.read because we do not want it to cache the object. Rather, we will cache the normalized type. final T dataType = kryo.newInstance(type); final FieldSerializer.CachedField[] fields = delegate.getFields(); for (int i = 0, n = fields.length; i < n; i++) { fields[i].read(input, dataType); } // be gentle to calcite and normalize the returned data type. normalization here means to use same type instances. final T result = (T) typeFactory.copyType(dataType); kryo.reference(result); return result; }
public static void register(final Kryo kryo) { // register list ImmutableListSerializer.register(kryo); // register set ImmutableSetSerializer.register(kryo); // register set ImmutableMapSerializer.register(kryo); // others kryo.addDefaultSerializer(FlatLists.AbstractFlatList.class, FieldSerializer.class); kryo.addDefaultSerializer(ImmutableNullableList.class, ImmutableNullableListSerializer.class); }
public void testDefaultTypes() { kryo.register(DefaultTypes.class); kryo.register(byte[].class); DefaultTypes test = new DefaultTypes(); test.booleanField = true; test.byteField = 123; test.charField = 'Z'; test.shortField = 12345; test.intField = 123456; test.longField = 123456789; test.floatField = 123.456f; test.doubleField = 1.23456d; test.BooleanField = true; test.ByteField = -12; test.CharacterField = 'X'; test.ShortField = -12345; test.IntegerField = -123456; test.LongField = -123456789l; test.FloatField = -123.3f; test.DoubleField = -0.121231d; test.StringField = "stringvalue"; test.byteArrayField = new byte[] { 2, 1, 0, -1, -2 }; roundTrip(78, 88, test); kryo.register(HasStringField.class); test.hasStringField = new HasStringField(); FieldSerializer serializer = (FieldSerializer) kryo .getSerializer(DefaultTypes.class); serializer.getField("hasStringField").setCanBeNull(false); roundTrip(79, 89, test); serializer.setFixedFieldTypes(true); serializer.getField("hasStringField").setCanBeNull(false); roundTrip(78, 88, test); }
public void testFieldRemoval() { kryo.register(DefaultTypes.class); kryo.register(byte[].class); kryo.register(HasStringField.class); HasStringField hasStringField = new HasStringField(); hasStringField.text = "moo"; roundTrip(4, 4, hasStringField); DefaultTypes test = new DefaultTypes(); test.intField = 12; test.StringField = "value"; test.CharacterField = 'X'; test.child = new DefaultTypes(); roundTrip(71, 91, test); supportsCopy = false; test.StringField = null; roundTrip(67, 87, test); FieldSerializer serializer = (FieldSerializer) kryo .getSerializer(DefaultTypes.class); serializer.removeField("LongField"); serializer.removeField("floatField"); serializer.removeField("FloatField"); roundTrip(55, 75, test); supportsCopy = true; }
@Override public Node read(Kryo kryo, Input input, Class<Node> nodeClass) { // TODO check if it is needed the same trick as in copy() Serializer<Node> serializer = new FieldSerializer<>(kryo, nodeClass); Node ret = serializer.read(kryo, input, nodeClass); ParentRegistry.registerTree(ret); return ret; }
public void testDefaultTypes () { kryo.register(DefaultTypes.class); kryo.register(byte[].class); DefaultTypes test = new DefaultTypes(); test.booleanField = true; test.byteField = 123; test.charField = 'Z'; test.shortField = 12345; test.intField = 123456; test.longField = 123456789; test.floatField = 123.456f; test.doubleField = 1.23456d; test.BooleanField = true; test.ByteField = -12; test.CharacterField = 'X'; test.ShortField = -12345; test.IntegerField = -123456; test.LongField = -123456789l; test.FloatField = -123.3f; test.DoubleField = -0.121231d; test.StringField = "stringvalue"; test.byteArrayField = new byte[] {2, 1, 0, -1, -2}; roundTrip(78, 88, test); kryo.register(HasStringField.class); test.hasStringField = new HasStringField(); FieldSerializer serializer = (FieldSerializer)kryo.getSerializer(DefaultTypes.class); serializer.getField("hasStringField").setCanBeNull(false); roundTrip(79, 89, test); serializer.setFixedFieldTypes(true); serializer.getField("hasStringField").setCanBeNull(false); roundTrip(78, 88, test); }
public void testFieldRemoval () { kryo.register(DefaultTypes.class); kryo.register(byte[].class); kryo.register(HasStringField.class); HasStringField hasStringField = new HasStringField(); hasStringField.text = "moo"; roundTrip(4, 4, hasStringField); DefaultTypes test = new DefaultTypes(); test.intField = 12; test.StringField = "value"; test.CharacterField = 'X'; test.child = new DefaultTypes(); roundTrip(71, 91, test); supportsCopy = false; test.StringField = null; roundTrip(67, 87, test); FieldSerializer serializer = (FieldSerializer)kryo.getSerializer(DefaultTypes.class); serializer.removeField("LongField"); serializer.removeField("floatField"); serializer.removeField("FloatField"); roundTrip(55, 75, test); supportsCopy = true; }
@Before public void setupConfig() { _conf = new Config(); _conf.setNumWorkers(2); _conf.registerSerialization(Path.class, FieldSerializer.class); _conf.registerSerialization(SequenceFile.Writer.class, FieldSerializer.class); _conf.registerSerialization(DenseVector.class, VectorSerializer.class); _conf.registerSerialization(Centroid.class, CentroidSerializer.class); _conf.put(Config.TOPOLOGY_TICK_TUPLE_FREQ_SECS, 5); _conf.put(HypercubeSpout.NUM_POINTS, 2000); _conf.put(HypercubeSpout.NUM_DIMENSION, 500); _conf.put(HypercubeSpout.NUM_CLUSTERS, NUM_CLUSTERS); _conf.put(HypercubeSpout.RADIUS, 0.0001); _conf.put(HypercubeSpout.UNIFORM_FRACTION, 0.0); _conf.put(DefaultOptionCreator.DISTANCE_MEASURE_OPTION, SquaredEuclideanDistanceMeasure.class.getName()); _conf.put(StreamingKMeansDriver.NUM_PROJECTIONS_OPTION, 3); _conf.put(StreamingKMeansDriver.SEARCH_SIZE_OPTION, 2); _conf.put(StreamingKMeansDriver.SEARCHER_CLASS_OPTION, FastProjectionSearch.class.getName()); _conf.put(StreamingKMeansDriver.ESTIMATED_NUM_MAP_CLUSTERS, ESTIMATED_NUM_MAP_CLUSTERS); _conf.put(StreamingKMeansDriver.ESTIMATED_DISTANCE_CUTOFF, 1e-7); _conf.put(HypercubeSpout.OUTPUT_PATH, INPUT_PATH); _conf.put(LocalSequenceFileWriterBolt.OUTPUT_PATH, OUTPUT_PATH); }
@Override public Serializer<?> getDefaultSerializer(@SuppressWarnings("rawtypes") final Class type) { final Serializer<?> result = super.getDefaultSerializer(type); if(result instanceof FieldSerializer) { // don't ignore synthetic fields so that inner classes work (see KryoTest.testInnerClass) ((FieldSerializer<?>) result).setIgnoreSyntheticFields(false); } return result; }
protected RelDataTypeSerializer(final Kryo kryo, final Class type, final RelDataTypeFactory typeFactory) { this.typeFactory = Preconditions.checkNotNull(typeFactory, "factory is required"); this.delegate = new FieldSerializer<>(kryo, type); }
@SuppressWarnings("rawtypes") protected static void removeField(Kryo kryo, Class type, String fieldName) { FieldSerializer fld = new FieldSerializer(kryo, type); fld.removeField(fieldName); kryo.register(type, fld); }
public void registerClasses(Kryo kryo) { kryo.register(AvgCount.class, new FieldSerializer(kryo, AvgCount.class)); }
public ContractFactory(Class<T> clazz) { this.kryo = new Kryo(); kryo.register(clazz, new FieldSerializer(kryo, clazz)); newInstance = createAndInitializeInstance(clazz); }
@SuppressWarnings({"unchecked", "rawtypes"}) @Override public void registerClasses(Kryo kryo) { // JsonSerializer is needed for the Google Genomics classes like Read and Reference. kryo.register(Read.class, new JsonSerializer<Read>()); //relatively inefficient serialization of Collections created with Collections.nCopies(), without this //any Collection created with Collections.nCopies fails to serialize at run time kryo.register(Collections.nCopies(2, "").getClass(), new FieldSerializer<>(kryo, Collections.nCopies(2, "").getClass())); // htsjdk.variant.variantcontext.CommonInfo has a Map<String, Object> that defaults to // a Collections.unmodifiableMap. This can't be handled by the version of kryo used in Spark, it's fixed // in newer versions (3.0.x), but we can't use those because of incompatibility with Spark. We just include the // fix here. // We are tracking this issue with (#874) kryo.register(Collections.unmodifiableMap(Collections.EMPTY_MAP).getClass(), new UnmodifiableCollectionsSerializer()); kryo.register(Collections.unmodifiableList(Collections.EMPTY_LIST).getClass(), new UnmodifiableCollectionsSerializer()); kryo.register(SAMRecordToGATKReadAdapter.class, new SAMRecordToGATKReadAdapterSerializer()); kryo.register(SAMRecord.class, new SAMRecordSerializer()); //register to avoid writing the full name of this class over and over kryo.register(PairedEnds.class, new FieldSerializer<>(kryo, PairedEnds.class)); // register the ADAM data types using Avro serialization, including: // AlignmentRecord // Genotype // Variant // DatabaseVariantAnnotation // NucleotideContigFragment // Contig // StructuralVariant // VariantCallingAnnotations // VariantEffect // DatabaseVariantAnnotation // Dbxref // Feature // ReferencePosition // ReferencePositionPair // SingleReadBucket // IndelRealignmentTarget // TargetSet // ZippedTargetSet ADAMregistrator.registerClasses(kryo); }
static public void register (Kryo kryo) { kryo.register(short[].class); kryo.register(SomeData.class, new DeflateSerializer(new FieldSerializer(kryo, SomeData.class))); kryo.register(ArrayList.class, new CollectionSerializer()); }
@Override public void write(Kryo kryo, Output output, Node node) { Serializer<Node> serializer = new FieldSerializer<>(kryo, node.getClass()); serializer.write(kryo, output, node); }