Java 类com.esotericsoftware.kryo.serializers.FieldSerializer 实例源码

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<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);
}

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);
}

@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 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 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);
}

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());
}