@SuppressWarnings({"unchecked", "rawtypes"})
private List<SerializedObject> upcastInternal(
List<SerializedObject> serializedObjects,
Iterator<Upcaster<?>> upcasterIterator,
UpcastingContext context) {
if (!upcasterIterator.hasNext()) {
return serializedObjects;
}
List<SerializedObject> upcastObjects = new ArrayList<>();
Upcaster<?> currentUpcaster = upcasterIterator.next();
for (SerializedObject serializedObject : serializedObjects) {
if (currentUpcaster.canUpcast(serializedObject.getType())) {
List<SerializedType> upcastTypes;
if (currentUpcaster instanceof ExtendedUpcaster) {
upcastTypes =
((ExtendedUpcaster) currentUpcaster)
.upcast(serializedObject.getType(), serializedObject);
} else {
upcastTypes = currentUpcaster.upcast(serializedObject.getType());
}
upcastObjects.addAll(doUpcast(currentUpcaster, serializedObject, upcastTypes, context));
} else {
upcastObjects.add(serializedObject);
}
}
return upcastInternal(upcastObjects, upcasterIterator, context);
}
public void testSupportSerializableDataType() throws Exception {
SerializedObject value = new SerializedObject();
value.value = 5;
test = EntityPropertyTest.FACTORY.initInstance("test1");
test.putIfAbsent();
EntityPropertyImpl<EntityPropertyTest, SerializedObject> prop =
new EntityPropertyImpl<EntityPropertyTest, SerializedObject>(
test.getEntityBasePropertyAccess(),
SerializedObject.class,
"serializable",
SerializableDataTypeTranslatorImpl.getInstance(SerializedObject.class),
true);
prop.set(value);
test.put();
prop =
new EntityPropertyImpl<EntityPropertyTest, SerializedObject>(
test.getEntityBasePropertyAccess(),
SerializedObject.class,
"serializable",
SerializableDataTypeTranslatorImpl.getInstance(SerializedObject.class),
true);
assertEquals(value, SerializedObject.class.cast(prop.get()));
}
/**
* 将旧的 serializedObject converter为 新的 serializedObject,如果expectedContentType 和旧的一致，那么直接返回 只是一个确认操作
*
* @param serializedObject The object to convert
* @param expectedContentType The content type of the SerializedObject to return
* @return a SerializedObject containing data in the expected content type
*/
@SuppressWarnings("unchecked")
protected <S, T> SerializedObject<T> ensureCorrectContentType(
SerializedObject<S> serializedObject, Class<T> expectedContentType) {
if (!expectedContentType.isAssignableFrom(serializedObject.getContentType())) {
ContentTypeConverter<S, T> converter =
converterFactory.getConverter(serializedObject.getContentType(), expectedContentType);
return converter.convert(serializedObject);
}
return (SerializedObject<T>) serializedObject;
}
/**
* Makes a copy of an object using serialization
*
* @param source the object to copy
* @return a copy of the source object
*/
protected Object copyObject(Object source) {
Object result = null;
try {
SerializedObject so = new SerializedObject(source);
result = so.getObject();
} catch (Exception ex) {
System.err.println("GenericObjectEditor: Problem making backup object");
System.err.println(source.getClass().getName());
ex.printStackTrace();
}
return result;
}
@SuppressWarnings("unchecked")
@Override
public <R> SerializedObject<R> serializeMetaData(
Serializer serializer, Class<R> expectedRepresentation) {
if (serializer.equals(serializedMetaData.getSerializer())) {
final SerializedObject serializedObject = serializedMetaData.getSerializedObject();
return CONVERTER_FACTORY
.getConverter(serializedObject.getContentType(), expectedRepresentation)
.convert(serializedObject);
}
return serializer.serialize(serializedMetaData.getObject(), expectedRepresentation);
}
private EventEntry(Serializer serializer, DomainEventMessage event) {
this.eventIdentifier = event.getIdentifier();
Class<?> serializationTarget = String.class;
if (serializer.canSerializeTo(DBObject.class)) {
serializationTarget = DBObject.class;
}
SerializedObject serializedPayloadObject =
serializePayload(event, serializer, serializationTarget);
SerializedObject serializedMetaDataObject =
serializeMetaData(event, serializer, serializationTarget);
this.serializedPayload = serializedPayloadObject.getData();
this.payloadType = serializedPayloadObject.getType().getName();
this.payloadRevision = serializedPayloadObject.getType().getRevision();
this.serializedMetaData = serializedMetaDataObject.getData();
this.sequenceNumber = event.getSequenceNumber();
this.timestamp = event.getTimestamp().toEpochMilli();
}
public void testSerialized() throws Exception {
SerializedObject value = new SerializedObject();
value.value = 5;
checkPropertyType(SerializedObject.class, value);
}
@Override
public SerializedObject<T> convert(SerializedObject<S> original) {
return new SimpleSerializedObject<>(
convert(original.getData()), targetType(), original.getType());
}
