/** {@inheritDoc} */ public Marshaller createMarshaller(final MarshallingConfiguration configuration) throws IOException { return new RiverMarshaller(this, registry, configuration); }
private RiverObjectOutputStream getObjectOutputStream() throws IOException { final RiverObjectOutputStream objectOutputStream = this.objectOutputStream; return objectOutputStream == null ? this.objectOutputStream = createObjectOutputStream() : objectOutputStream; }
protected void doWriteSerializableObject(final SerializableClass info, final Object obj, final Class<?> objClass) throws IOException { final Class<?> superclass = objClass.getSuperclass(); if (superclass != null && serializabilityChecker.isSerializable(superclass)) { doWriteSerializableObject(registry.lookup(superclass), obj, superclass); } if (info.hasWriteObject()) { final RiverObjectOutputStream objectOutputStream = getObjectOutputStream(); final SerializableClass oldInfo = objectOutputStream.swapClass(info); final Object oldObj = objectOutputStream.swapCurrent(obj); final int restoreState = objectOutputStream.start(); boolean ok = false; try { info.callWriteObject(obj, objectOutputStream); objectOutputStream.finish(restoreState); writeEndBlock(); objectOutputStream.swapCurrent(oldObj); objectOutputStream.swapClass(oldInfo); ok = true; } finally { if (! ok) { objectOutputStream.fullReset(); } } } else { doWriteFields(info, obj); } }
protected boolean writeKnownClass(final Class<?> objClass) throws IOException { final int configuredVersion = this.configuredVersion; int i = getBasicClasses(configuredVersion).get(objClass, -1); if (i != -1) { write(i); return true; } i = classCache.get(objClass, -1); if (i != -1) { final int diff = i - classSeq; if (diff >= -256) { write(ID_REPEAT_CLASS_NEAR); write(diff); } else if (diff >= -65536) { write(ID_REPEAT_CLASS_NEARISH); writeShort(diff); } else { write(ID_REPEAT_CLASS_FAR); writeInt(i); } return true; } return false; }
private void writeClassTableData(final Class<?> objClass, final ClassTable.Writer classTableWriter) throws IOException { if (configuredVersion == 1) { classTableWriter.writeClass(getBlockMarshaller(), objClass); writeEndBlock(); } else { classTableWriter.writeClass(this, objClass); } }
protected void writeNewProxyClass(final Class<?> objClass) throws IOException { ClassTable.Writer classTableWriter = classTable.getClassWriter(objClass); if (classTableWriter != null) { write(ID_PREDEFINED_PROXY_CLASS); classCache.put(objClass, classSeq++); writeClassTableData(objClass, classTableWriter); } else { write(ID_PROXY_CLASS); final String[] names = classResolver.getProxyInterfaces(objClass); writeInt(names.length); for (String name : names) { writeString(name); } classCache.put(objClass, classSeq++); if (configuredVersion == 1) { final BlockMarshaller blockMarshaller = getBlockMarshaller(); classResolver.annotateProxyClass(blockMarshaller, objClass); writeEndBlock(); } else { classResolver.annotateProxyClass(this, objClass); } } }
for (;;) { if (obj == null) { write(ID_NULL); return; final int diff = rid - instanceSeq; if (diff >= -256) { write(ID_REPEAT_OBJECT_NEAR); write(diff); } else if (diff >= -65536) { write(ID_REPEAT_OBJECT_NEARISH); writeShort(diff); } else { write(ID_REPEAT_OBJECT_FAR); writeInt(rid); final ObjectTable.Writer objectTableWriter; if (! unshared && (objectTableWriter = objectTable.getObjectWriter(obj)) != null) { write(ID_PREDEFINED_OBJECT); if (configuredVersion == 1) { objectTableWriter.writeObject(getBlockMarshaller(), obj); writeEndBlock(); } else { objectTableWriter.writeObject(this, obj); id = getBasicClasses(configuredVersion).get(objClass, -1); write(ID_NEW_OBJECT); writeClassClass(classObj);
switch (serializableField.getKind()) { case BOOLEAN: { writeBoolean(serializableField.isAccessible() && serializableField.getBoolean(obj)); break; writeByte(serializableField.isAccessible() ? serializableField.getByte(obj) : 0); break; writeShort(serializableField.isAccessible() ? serializableField.getShort(obj) : 0); break; writeInt(serializableField.isAccessible() ? serializableField.getInt(obj) : 0); break; writeChar(serializableField.isAccessible() ? serializableField.getChar(obj) : 0); break; writeLong(serializableField.isAccessible() ? serializableField.getLong(obj) : 0); break; writeDouble(serializableField.isAccessible() ? serializableField.getDouble(obj) : 0); break; writeFloat(serializableField.isAccessible() ? serializableField.getFloat(obj) : 0); break; doWriteObject(serializableField.isAccessible() ? serializableField.getObject(obj) : null, serializableField.isUnshared()); break;
protected ObjectOutput getObjectOutput() { final ObjectOutput output = objectOutput; return output == null ? (objectOutput = getBlockMarshaller()) : output; }
private void doWriteObject(final Object obj, final boolean unshared) throws IOException { flush(); riverMarshaller.doWriteObject(obj, unshared); flush(); }
public void defaultWriteObject() throws IOException { if (! compareAndSetState(UNWRITTEN_FIELDS, ON)) { throw new NotActiveException("writeFields() may only be called when the fields have not yet been written"); } try { marshaller.doWriteFields(serializableClass, current); } finally { putField = null; serializableClass = null; current = null; } }
for (;;) { if (obj == null) { write(ID_NULL); return; final int diff = rid - instanceSeq; if (diff >= -256) { write(ID_REPEAT_OBJECT_NEAR); write(diff); } else if (diff >= -65536) { write(ID_REPEAT_OBJECT_NEARISH); writeShort(diff); } else { write(ID_REPEAT_OBJECT_FAR); writeInt(rid); write(ID_REPEAT_OBJECT_FAR); writeInt(rid); return; write(ID_PREDEFINED_OBJECT); if (configuredVersion == 1) { objectTableWriter.writeObject(getBlockMarshaller(), obj); writeEndBlock(); } else { objectTableWriter.writeObject(this, obj); id = getBasicClasses(configuredVersion).get(objClass, -1);
switch (serializableField.getKind()) { case BOOLEAN: { writeBoolean(field.getBoolean(obj)); break; writeByte(field.getByte(obj)); break; writeShort(field.getShort(obj)); break; writeInt(field.getInt(obj)); break; writeChar(field.getChar(obj)); break; writeLong(field.getLong(obj)); break; writeDouble(field.getDouble(obj)); break; writeFloat(field.getFloat(obj)); break; doWriteObject(field.get(obj), serializableField.isUnshared()); break;
protected void writeNewProxyClass(final Class<?> objClass) throws IOException { ClassTable.Writer classTableWriter = classTable.getClassWriter(objClass); if (classTableWriter != null) { write(ID_PREDEFINED_PROXY_CLASS); classCache.put(objClass, classSeq++); writeClassTableData(objClass, classTableWriter); } else { write(ID_PROXY_CLASS); final String[] names = classResolver.getProxyInterfaces(objClass); writeInt(names.length); for (String name : names) { writeString(name); } classCache.put(objClass, classSeq++); if (configuredVersion == 1) { final BlockMarshaller blockMarshaller = getBlockMarshaller(); classResolver.annotateProxyClass(blockMarshaller, objClass); writeEndBlock(); } else { classResolver.annotateProxyClass(this, objClass); } } }
protected boolean writeKnownClass(final Class<?> objClass) throws IOException { final int configuredVersion = this.configuredVersion; int i = getBasicClasses(configuredVersion).get(objClass, -1); if (i != -1) { write(i); return true; } i = classCache.get(objClass, -1); if (i != -1) { final int diff = i - classSeq; if (diff >= -256) { write(ID_REPEAT_CLASS_NEAR); write(diff); } else if (diff >= -65536) { write(ID_REPEAT_CLASS_NEARISH); writeShort(diff); } else { write(ID_REPEAT_CLASS_FAR); writeInt(i); } return true; } return false; }
protected void doAnnotateClass(final Class<?> objClass) throws IOException { if (configuredVersion == 1) { classResolver.annotateClass(getBlockMarshaller(), objClass); writeEndBlock(); } else { classResolver.annotateClass(this, objClass); } }
public RiverObjectOutputStream run() throws IOException { return new RiverObjectOutputStream(getBlockMarshaller(), RiverMarshaller.this); } };
private void doWriteObject(final Object obj, final boolean unshared) throws IOException { flush(); riverMarshaller.doWriteObject(obj, unshared); flush(); }
public void defaultWriteObject() throws IOException { if (! state.compareAndSet(State.UNWRITTEN_FIELDS, State.ON)) { throw new NotActiveException("writeFields() may only be called when the fields have not yet been written"); } try { marshaller.doWriteFields(serializableClass, current); } finally { putField = null; serializableClass = null; current = null; } }
for (;;) { if (obj == null) { write(ID_NULL); return; final int diff = rid - instanceSeq; if (diff >= -256) { write(ID_REPEAT_OBJECT_NEAR); write(diff); } else if (diff >= -65536) { write(ID_REPEAT_OBJECT_NEARISH); writeShort(diff); } else { write(ID_REPEAT_OBJECT_FAR); writeInt(rid); final ObjectTable.Writer objectTableWriter; if (! unshared && (objectTableWriter = objectTable.getObjectWriter(obj)) != null) { write(ID_PREDEFINED_OBJECT); if (configuredVersion == 1) { objectTableWriter.writeObject(getBlockMarshaller(), obj); writeEndBlock(); } else { objectTableWriter.writeObject(this, obj); id = getBasicClasses(configuredVersion).get(objClass, -1); write(ID_NEW_OBJECT); writeClassClass(classObj);