@Override
public void write(Externalizable externalizable, BufferOutput<?> buffer, Serializer serializer) {
try {
externalizable.writeExternal(new BufferObjectOutput(buffer, serializer));
} catch (IOException e) {
throw new SerializationException(
"failed to serialize externalizable type: " + externalizable.getClass(), e);
}
}
public void defaultWriteObject(Object toWrite, FSTClazzInfo serializationInfo)
throws IOException {
if (serializationInfo.isExternalizable()) {
codec.ensureFree(writeExternalWriteAhead);
((Externalizable) toWrite).writeExternal(this);
} else {
FSTClazzInfo.FSTFieldInfo[] fieldInfo = serializationInfo.getFieldInfo();
writeObjectFields(toWrite, serializationInfo, fieldInfo, 0, 0);
}
}
@Override
public void marshall(
Object value,
PropertyDescriptor propertyDescriptor,
DataOutput dataOutput,
SerializationContext serializationContext)
throws IOException {
((Externalizable) value).writeExternal((ObjectOutput) dataOutput);
}
private void externalize(final Externalizable original, final Externalizable copy)
throws IOException, ClassNotFoundException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
final ObjectOutputStream out = new ObjectOutputStream(baos);
original.writeExternal(out);
out.close();
final ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
final ObjectInputStream in = new ObjectInputStream(bais);
copy.readExternal(in);
}
@Override
public void write(final ObjectDataOutput out, final Externalizable obj) throws IOException {
out.writeUTF(obj.getClass().getName());
final ObjectOutputStream objectOutputStream;
final OutputStream outputStream = (OutputStream) out;
GZIPOutputStream gzip = null;
if (gzipEnabled) {
gzip = new GZIPOutputStream(outputStream);
objectOutputStream = new ObjectOutputStream(gzip);
} else {
objectOutputStream = new ObjectOutputStream(outputStream);
}
obj.writeExternal(objectOutputStream);
// Force flush if not yet written due to internal behavior if pos < 1024
objectOutputStream.flush();
if (gzipEnabled) {
gzip.finish();
}
}
private void writeExternal(ObjectOutput out, char b, ISOComponent c) throws IOException {
out.writeByte(b);
((Externalizable) c).writeExternal(out);
}
@Override
protected void writeObject(ObjectOutput out, Object obj) throws IOException {
((Externalizable) obj).writeExternal(out);
}
private void internalCheck(Object obj) {
if (obj == null) {
return;
}
Class<?> cls = obj.getClass();
nameStack.add(simpleName);
traceStack.add(new TraceSlot(obj, fieldDescription));
if (!(obj instanceof Serializable) && (!Proxy.isProxyClass(cls))) {
throw new WicketSerializableCheckException(
toPrettyPrintedStack(obj.getClass(), "field that is not serializable"));
}
serializableCheck.inspect(obj, stackTracePrinter);
ObjectStreamClass desc;
for (; ; ) {
try {
desc = (ObjectStreamClass) LOOKUP_METHOD.invoke(null, cls, Boolean.TRUE);
Class<?> repCl;
if (!(Boolean) HAS_WRITE_REPLACE_METHOD_METHOD.invoke(desc, (Object[]) null)
|| (obj = INVOKE_WRITE_REPLACE_METHOD.invoke(desc, obj)) == null
|| (repCl = obj.getClass()) == cls) {
break;
}
cls = repCl;
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}
if (cls.isPrimitive()) {
// skip
} else if (cls.isArray()) {
checked.put(obj, null);
Class<?> ccl = cls.getComponentType();
if (!(ccl.isPrimitive())) {
Object[] objs = (Object[]) obj;
for (int i = 0; i < objs.length; i++) {
String arrayPos = "[" + i + "]";
simpleName = arrayPos;
fieldDescription += arrayPos;
check(objs[i]);
}
}
} else if (obj instanceof Externalizable && (!Proxy.isProxyClass(cls))) {
Externalizable extObj = (Externalizable) obj;
try {
extObj.writeExternal(
new ObjectOutputAdaptor() {
private int count = 0;
public void writeObject(Object streamObj) throws IOException {
// Check for circular reference.
if (checked.containsKey(streamObj)) {
return;
}
checked.put(streamObj, null);
String arrayPos = "[write:" + count++ + "]";
simpleName = arrayPos;
fieldDescription += arrayPos;
check(streamObj);
}
});
} catch (Exception e) {
if (e instanceof WicketSerializableCheckException) {
throw (WicketSerializableCheckException) e;
}
log.warn(
"error delegating to Externalizable : " + e.getMessage() + ", path: " + currentPath());
}
} else {
Method writeObjectMethod = null;
if (writeObjectMethodMissing.contains(cls) == false) {
try {
writeObjectMethod =
cls.getDeclaredMethod("writeObject", new Class[] {java.io.ObjectOutputStream.class});
} catch (SecurityException e) {
// we can't access / set accessible to true
writeObjectMethodMissing.add(cls);
} catch (NoSuchMethodException e) {
// cls doesn't have that method
writeObjectMethodMissing.add(cls);
}
}
final Object original = obj;
if (writeObjectMethod != null) {
class InterceptingObjectOutputStream extends ObjectOutputStream {
private int counter;
InterceptingObjectOutputStream() throws IOException {
super(DUMMY_OUTPUT_STREAM);
enableReplaceObject(true);
}
@Override
protected Object replaceObject(Object streamObj) throws IOException {
if (streamObj == original) {
return streamObj;
}
counter++;
// Check for circular reference.
if (checked.containsKey(streamObj)) {
return null;
}
checked.put(streamObj, null);
String arrayPos = "[write:" + counter + "]";
simpleName = arrayPos;
fieldDescription += arrayPos;
check(streamObj);
return streamObj;
}
}
try {
InterceptingObjectOutputStream ioos = new InterceptingObjectOutputStream();
ioos.writeObject(obj);
} catch (Exception e) {
if (e instanceof WicketSerializableCheckException) {
throw (WicketSerializableCheckException) e;
}
log.warn(
"error delegating to writeObject : " + e.getMessage() + ", path: " + currentPath());
}
} else {
Object[] slots;
try {
slots = (Object[]) GET_CLASS_DATA_LAYOUT_METHOD.invoke(desc, (Object[]) null);
} catch (Exception e) {
throw new RuntimeException(e);
}
for (Object slot : slots) {
ObjectStreamClass slotDesc;
try {
Field descField = slot.getClass().getDeclaredField("desc");
descField.setAccessible(true);
slotDesc = (ObjectStreamClass) descField.get(slot);
} catch (Exception e) {
throw new RuntimeException(e);
}
checked.put(obj, null);
checkFields(obj, slotDesc);
}
}
}
traceStack.removeLast();
nameStack.removeLast();
}