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; }
if (! unshared && (rid = instanceCache.get(obj, -1)) != -1) { final int diff = rid - instanceSeq; if (diff >= -256) { id = getBasicClasses(configuredVersion).get(objClass, -1); final int cid = BASIC_CLASSES_V2.get(classObj, -1); switch (cid) { case -1: writeEnumClass(theEnum.getDeclaringClass()); writeString(theEnum.name()); instanceCache.put(obj, instanceSeq++); return; UTFUtils.writeUTFBytes(byteOutput, string); if (unshared) { instanceCache.put(obj, -1); instanceSeq++; } else { instanceCache.put(obj, instanceSeq++); instanceCache.put(obj, instanceSeq++); instanceCache.put(obj, -1); instanceCache.put(obj, instanceSeq++); instanceCache.put(obj, -1);
protected RiverMarshaller(final RiverMarshallerFactory marshallerFactory, final SerializableClassRegistry registry, final MarshallingConfiguration configuration) throws IOException { super(marshallerFactory, configuration); final int configuredVersion = this.configuredVersion; if (configuredVersion < MIN_VERSION || configuredVersion > MAX_VERSION) { throw new IOException("Unsupported protocol version " + configuredVersion); } this.registry = registry; final float loadFactor = 0x0.5p0f; instanceCache = new IdentityIntMap<Object>((int) ((double)configuration.getInstanceCount() / (double)loadFactor), loadFactor); classCache = new IdentityIntMap<Class<?>>((int) ((double)configuration.getClassCount() / (double)loadFactor), loadFactor); externalizers = new IdentityHashMap<Class<?>, Externalizer>(configuration.getClassCount()); }
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); } }
/** * Put a value into the map. Any previous mapping is discarded silently. * * @param key the key * @param value the value to store */ public void put(T key, int value) { final Object[] keys = this.keys; final int mask = keys.length - 1; final int[] values = this.values; Object v; int hc = System.identityHashCode(key) & mask; for (int idx = hc;; idx = hc++ & mask) { v = keys[idx]; if (v == null) { keys[idx] = key; values[idx] = value; if (++count > resizeCount) { resize(); } return; } if (v == key) { values[idx] = value; return; } } }
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); } }
/** * Put a value into the map. Any previous mapping is discarded silently. * * @param key the key * @param value the value to store */ public void put(T key, int value) { final Object[] keys = this.keys; final int mask = keys.length - 1; final int[] values = this.values; Object v; int hc = System.identityHashCode(key) & mask; for (int idx = hc;; idx = hc++ & mask) { v = keys[idx]; if (v == null) { keys[idx] = key; values[idx] = value; if (++count > resizeCount) { resize(); } return; } if (v == key) { values[idx] = value; return; } } }
private static Object simpleClone(final Object orig, final Class<?> objClass) { final int idx = PRIMITIVE_ARRAYS.get(objClass, -1); switch (idx) { case 0: {
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 RiverMarshaller(final RiverMarshallerFactory marshallerFactory, final SerializableClassRegistry registry, final MarshallingConfiguration configuration) throws IOException { super(marshallerFactory, configuration); final int configuredVersion = this.configuredVersion; if (configuredVersion < MIN_VERSION || configuredVersion > MAX_VERSION) { throw new IOException("Unsupported protocol version " + configuredVersion); } this.registry = registry; final float loadFactor = 0x0.5p0f; instanceCache = new IdentityIntMap<Object>((int) ((double)configuration.getInstanceCount() / (double)loadFactor), loadFactor); classCache = new IdentityIntMap<Class<?>>((int) ((double)configuration.getClassCount() / (double)loadFactor), loadFactor); externalizers = new IdentityHashMap<Class<?>, Externalizer>(configuration.getClassCount()); }
/** * Put a value into the map. Any previous mapping is discarded silently. * * @param key the key * @param value the value to store */ public void put(T key, int value) { final Object[] keys = this.keys; final int mask = keys.length - 1; final int[] values = this.values; Object v; int hc = System.identityHashCode(key) & mask; for (int idx = hc;; idx = hc++ & mask) { v = keys[idx]; if (v == null) { keys[idx] = key; values[idx] = value; if (++count > resizeCount) { resize(); } return; } if (v == key) { values[idx] = value; return; } } }
@Override public void writeObject(ObjectOutput out, Equivalence obj) throws IOException { int subId = subIds.get(obj.getClass(), -1); out.writeByte(subId); }
if (! unshared && (v = instanceCache.get(obj, -1)) != -1) { write(TC_REFERENCE); writeInt(v + baseWireHandle); write(TC_OBJECTTABLE); final int id = instanceSeq++; if (! unshared) instanceCache.put(obj, id); writer.writeObject(blockMarshaller, obj); doEndBlock(); writeNewClassDescFor((Class<?>)obj); final int id = instanceSeq++; if (! unshared) instanceCache.put(obj, id); return; } else if (obj instanceof ObjectStreamClass) { write(TC_NULL); return; } else if (! unshared && (v = instanceCache.get(obj, -1)) != -1) { write(TC_REFERENCE); writeInt(v); writeNewClassDescFor((Class<?>)obj); final int id = instanceSeq++; if (! unshared) instanceCache.put(obj, id); return; } else if (obj instanceof ObjectStreamClass) { write(TC_STRING);
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 RiverMarshaller(final RiverMarshallerFactory marshallerFactory, final SerializableClassRegistry registry, final MarshallingConfiguration configuration) throws IOException { super(marshallerFactory, configuration); final int configuredVersion = this.configuredVersion; if (configuredVersion < MIN_VERSION || configuredVersion > MAX_VERSION) { throw new IOException("Unsupported protocol version " + configuredVersion); } this.registry = registry; final float loadFactor = 0x0.5p0f; instanceCache = new IdentityIntMap<Object>((int) ((double)configuration.getInstanceCount() / (double)loadFactor), loadFactor); classCache = new IdentityIntMap<Class<?>>((int) ((double)configuration.getClassCount() / (double)loadFactor), loadFactor); externalizers = new IdentityHashMap<Class<?>, Externalizer>(configuration.getClassCount()); }