protected void writeClassClass(final Class<?> classObj) throws IOException { write(ID_CLASS_CLASS); writeClass(classObj); // not cached }
public void flush() throws IOException { final int position = this.position; if (position == 0) { return; } final RiverMarshaller marshaller = riverMarshaller; if (position < 256) { marshaller.write(Protocol.ID_START_BLOCK_SMALL); marshaller.writeByte(position); } else if (position < 65536) { marshaller.write(Protocol.ID_START_BLOCK_MEDIUM); marshaller.writeShort(position); } else { marshaller.write(Protocol.ID_START_BLOCK_LARGE); marshaller.writeInt(position); } marshaller.write(buffer, 0, position); this.position = 0; }
private void writeBooleanArray(final boolean[] booleans) throws IOException { final int len = booleans.length; final int bc = len & ~7; for (int i = 0; i < bc;) { write( (booleans[i++] ? 1 : 0) | (booleans[i++] ? 2 : 0) | (booleans[i++] ? 4 : 0) | (booleans[i++] ? 8 : 0) | (booleans[i++] ? 16 : 0) | (booleans[i++] ? 32 : 0) | (booleans[i++] ? 64 : 0) | (booleans[i++] ? 128 : 0) ); } if (bc < len) { int out = 0; int bit = 1; for (int i = bc; i < len; i++) { if (booleans[i]) out |= bit; bit <<= 1; } write(out); } }
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); write(ID_NEW_OBJECT); writeClassClass(classObj); return; write(cid); return;
protected void writeNewSerializableClass(final Class<?> objClass) throws IOException { ClassTable.Writer classTableWriter = classTable.getClassWriter(objClass); if (classTableWriter != null) { write(ID_PREDEFINED_SERIALIZABLE_CLASS); classCache.put(objClass, classSeq++); writeClassTableData(objClass, classTableWriter); final SerializableClass info = registry.lookup(objClass); if (info.hasWriteObject()) { write(ID_WRITE_OBJECT_CLASS); } else { write(ID_SERIALIZABLE_CLASS); write(ID_OBJECT_CLASS); return;
protected void writeNewClass(final Class<?> objClass) throws IOException { if (objClass.isEnum()) { writeNewEnumClass(objClass.asSubclass(Enum.class)); } else if (Proxy.class.isAssignableFrom(objClass)) { writeNewProxyClass(objClass); } else if (objClass.isArray()) { writeObjectArrayClass(objClass); } else if (! objClass.isInterface() && serializabilityChecker.isSerializable(objClass)) { if (Externalizable.class.isAssignableFrom(objClass)) { writeNewExternalizableClass(objClass); } else { writeNewSerializableClass(objClass); } } else { ClassTable.Writer classTableWriter = classTable.getClassWriter(objClass); if (classTableWriter != null) { write(ID_PREDEFINED_PLAIN_CLASS); classCache.put(objClass, classSeq++); writeClassTableData(objClass, classTableWriter); } else { write(ID_PLAIN_CLASS); writeString(classResolver.getClassName(objClass)); classResolver.annotateClass(this, objClass); classCache.put(objClass, classSeq++); } } }
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 void writeNewExternalizerClass(final Class<?> objClass, final Externalizer externalizer) throws IOException { ClassTable.Writer classTableWriter = classTable.getClassWriter(objClass); if (classTableWriter != null) { write(ID_PREDEFINED_EXTERNALIZER_CLASS); classCache.put(objClass, classSeq++); writeClassTableData(objClass, classTableWriter); } else { write(ID_EXTERNALIZER_CLASS); writeString(classResolver.getClassName(objClass)); classCache.put(objClass, classSeq++); classResolver.annotateClass(this, objClass); } writeObject(externalizer); }
protected void writeNewExternalizableClass(final Class<?> objClass) throws IOException { ClassTable.Writer classTableWriter = classTable.getClassWriter(objClass); if (classTableWriter != null) { write(ID_PREDEFINED_EXTERNALIZABLE_CLASS); classCache.put(objClass, classSeq++); writeClassTableData(objClass, classTableWriter); } else { write(ID_EXTERNALIZABLE_CLASS); writeString(classResolver.getClassName(objClass)); writeLong(registry.lookup(objClass).getEffectiveSerialVersionUID()); classCache.put(objClass, classSeq++); classResolver.annotateClass(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 writeNewEnumClass(final Class<? extends Enum> objClass) throws IOException { ClassTable.Writer classTableWriter = classTable.getClassWriter(objClass); if (classTableWriter != null) { write(ID_PREDEFINED_ENUM_TYPE_CLASS); classCache.put(objClass, classSeq++); writeClassTableData(objClass, classTableWriter); } else { write(ID_ENUM_TYPE_CLASS); writeString(classResolver.getClassName(objClass)); classCache.put(objClass, classSeq++); classResolver.annotateClass(this, objClass); } }
public void write(final byte[] bytes, final int off, final int len) throws IOException { if (len < 1) { return; } final int bl = buffer.length; final int position = this.position; if (len > bl - position || len > bl >> 1) { flush(); if (len < 256) { riverMarshaller.write(Protocol.ID_START_BLOCK_SMALL); riverMarshaller.writeByte(len); riverMarshaller.write(bytes, off, len); } else if (len < 65536) { riverMarshaller.write(Protocol.ID_START_BLOCK_MEDIUM); riverMarshaller.writeShort(len); riverMarshaller.write(bytes, off, len); } else { riverMarshaller.write(Protocol.ID_START_BLOCK_LARGE); riverMarshaller.writeInt(len); riverMarshaller.write(bytes, off, len); } } else { System.arraycopy(bytes, off, buffer, position, len); this.position = position + len; } }
protected void writeObjectArrayClass(final Class<?> objClass) throws IOException { write(ID_OBJECT_ARRAY_TYPE_CLASS); writeClass(objClass.getComponentType()); classCache.put(objClass, classSeq++); }
public void clearInstanceCache() throws IOException { instanceCache.clear(); instanceSeq = 0; if (byteOutput != null) { write(ID_CLEAR_INSTANCE_CACHE); } }
protected void writeClassClass(final Class<?> classObj) throws IOException { write(ID_CLASS_CLASS); writeClass(classObj); // not cached }
public void clearClassCache() throws IOException { classCache.clear(); externalizers.clear(); classSeq = 0; instanceCache.clear(); instanceSeq = 0; if (byteOutput != null) { write(ID_CLEAR_CLASS_CACHE); } }
protected void writeObjectArrayClass(final Class<?> objClass) throws IOException { write(ID_OBJECT_ARRAY_TYPE_CLASS); writeClass(objClass.getComponentType()); classCache.put(objClass, classSeq++); }
public void clearInstanceCache() throws IOException { instanceCache.clear(); instanceSeq = 0; if (byteOutput != null) { write(ID_CLEAR_INSTANCE_CACHE); } }
public void clearClassCache() throws IOException { classCache.clear(); externalizers.clear(); classSeq = 0; instanceCache.clear(); instanceSeq = 0; if (byteOutput != null) { write(ID_CLEAR_CLASS_CACHE); } }
public void clearClassCache() throws IOException { classCache.clear(); externalizers.clear(); classSeq = 0; instanceCache.clear(); instanceSeq = 0; if (byteOutput != null) { write(ID_CLEAR_CLASS_CACHE); } }