@Override public Object readUnshared() throws IOException, ClassNotFoundException { return wrapped.readUnshared(); }
/** {@inheritDoc} */ public Object readObjectUnshared() throws IOException, ClassNotFoundException { return ois.readUnshared(); }
@Override public Object readUnshared() throws IOException, ClassNotFoundException { return wrapped.readUnshared(); }
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { // We do unshared reads here to ensure we have our own clones of the byte[]s. encodedParams = (byte[]) s.readUnshared(); encryptedContent = (byte[]) s.readUnshared(); // These are regular shared reads because the algorithms used by a given stream are // almost certain to the be same for each object, and String is immutable anyway, // so there's no security concern about sharing. sealAlg = (String) s.readObject(); paramsAlg = (String) s.readObject(); }
Object toSet = fieldDesc.isUnshared() ? readUnshared() : readObject(); if (toSet != null) {
/** {@inheritDoc} */ public Object readObjectUnshared() throws IOException, ClassNotFoundException { return ois.readUnshared(); }
/** * Reads the next object from the given input stream. The default * implementation uses {@link java.io.ObjectInputStream#readUnshared}. * Subclasses may choose to change this behavior by overriding this method. * * @param istream the input stream from which to read the next object * @return the next object read */ protected Object deserializeObject(ObjectInputStream istream) throws IOException, ClassNotFoundException { return istream.readUnshared(); }
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { // We do unshared reads here to ensure we have our own clones of the byte[]s. encodedParams = (byte[]) s.readUnshared(); encryptedContent = (byte[]) s.readUnshared(); // These are regular shared reads because the algorithms used by a given stream are // almost certain to the be same for each object, and String is immutable anyway, // so there's no security concern about sharing. sealAlg = (String) s.readObject(); paramsAlg = (String) s.readObject(); }
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { // We do unshared reads here to ensure we have our own clones of the byte[]s. encodedParams = (byte[]) s.readUnshared(); encryptedContent = (byte[]) s.readUnshared(); // These are regular shared reads because the algorithms used by a given stream are // almost certain to the be same for each object, and String is immutable anyway, // so there's no security concern about sharing. sealAlg = (String) s.readObject(); paramsAlg = (String) s.readObject(); }
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { // We do unshared reads here to ensure we have our own clones of the byte[]s. encodedParams = (byte[]) s.readUnshared(); encryptedContent = (byte[]) s.readUnshared(); // These are regular shared reads because the algorithms used by a given stream are // almost certain to the be same for each object, and String is immutable anyway, // so there's no security concern about sharing. sealAlg = (String) s.readObject(); paramsAlg = (String) s.readObject(); }
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { // We do unshared reads here to ensure we have our own clones of the byte[]s. encodedParams = (byte[]) s.readUnshared(); encryptedContent = (byte[]) s.readUnshared(); // These are regular shared reads because the algorithms used by a given stream are // almost certain to the be same for each object, and String is immutable anyway, // so there's no security concern about sharing. sealAlg = (String) s.readObject(); paramsAlg = (String) s.readObject(); }
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException { // We do unshared reads here to ensure we have our own clones of the byte[]s. encodedParams = (byte[]) s.readUnshared(); encryptedContent = (byte[]) s.readUnshared(); // These are regular shared reads because the algorithms used by a given stream are // almost certain to the be same for each object, and String is immutable anyway, // so there's no security concern about sharing. sealAlg = (String) s.readObject(); paramsAlg = (String) s.readObject(); }
/** Deserialize a stream to an object. */ @SuppressWarnings("unchecked") private T deserialize(InputStream in) throws IOException { ObjectInputStream oin = new ObjectInputStream(new BufferedInputStream(in, 1024)); T entry; try { entry = (T) oin.readUnshared(); } catch (ClassNotFoundException e) { // This can only happen if we make an incompatible change. throw new AssertionError(e); } return entry; }
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { apdu = (byte[])in.readUnshared(); // initialize transient fields parse(); }
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { apdu = (byte[])in.readUnshared(); check(apdu); }
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { apdu = (byte[])in.readUnshared(); check(apdu); }
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { apdu = (byte[])in.readUnshared(); // initialize transient fields parse(); }
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException { apdu = (byte[])in.readUnshared(); // initialize transient fields parse(); }
private Object read(InputStream in, ClassLoader classLoader) throws IOException { try { ObjectInputStream objectInputStream = newObjectInputStream(classLoader, classFilter, in); if (shared) { return objectInputStream.readObject(); } return objectInputStream.readUnshared(); } catch (ClassNotFoundException e) { throw new HazelcastSerializationException(e); } }
private Object read(InputStream in, ClassLoader classLoader) throws IOException { try { ObjectInputStream objectInputStream = newObjectInputStream(classLoader, classFilter, in); if (shared) { return objectInputStream.readObject(); } return objectInputStream.readUnshared(); } catch (ClassNotFoundException e) { throw new HazelcastSerializationException(e); } }