@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);
   }
 }
 @Override
 public Externalizable read(
     Class<Externalizable> type, BufferInput<?> buffer, Serializer serializer) {
   try {
     Externalizable externalizable = type.newInstance();
     externalizable.readExternal(new BufferObjectInput(buffer, serializer));
     return externalizable;
   } catch (InstantiationException | IllegalAccessException e) {
     throw new SerializationException("failed to instantiate externalizable type: " + type, e);
   } catch (IOException | ClassNotFoundException e) {
     throw new SerializationException("failed to deserialize externalizable type: " + type, e);
   }
 }
Beispiel #3
0
  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);
  }
Beispiel #4
0
 private static Object readRealObject(byte type, InputStream is, ClassLoader loader)
     throws IOException {
   try {
     if (type == 0) {
       return PDataStream.readUTF(is);
     } else if (type == 1) {
       return new Integer(PDataStream.readInt(is));
     } else if (type == 2) {
       return new Long(PDataStream.readLong(is));
     } else if (type == 3) {
       return new Byte((byte) is.read());
     } else if (type == 4) {
       return PDataStream.readBoolean(is) ? Boolean.TRUE : Boolean.FALSE;
     } else if (type == 5) {
       return new Character(PDataStream.readChar(is));
     } else if (type == 6) {
       return new Short(PDataStream.readShort(is));
     } else if (type == 7) {
       return new Float(PDataStream.readFloat(is));
     } else if (type == 8) {
       return new Double(PDataStream.readDouble(is));
     } else if (type == 11) {
       String name = PDataStream.readUTF(is);
       Class c = loader == null ? Class.forName(name) : loader.loadClass(name);
       if (Externalizable.class.isAssignableFrom(c)) {
         Externalizable obj = (Externalizable) c.newInstance();
         obj.readObject(is);
         return obj;
       }
       throw new IOException("Could not read object " + name);
     } else if (type == 12) {
       ObjectInputStream in =
           loader == null
               ? new ObjectInputStream(is)
               : (ObjectInputStream) new XObjectInputStream(loader, is);
       return in.readObject();
     }
   } catch (ClassNotFoundException cnfe) {
     throw new IOException("Could not find class " + cnfe.toString());
   } catch (Exception exc) {
     throw exc instanceof IOException
         ? (IOException) exc
         : new IOException("Could not read object " + exc.toString());
   }
   throw new IllegalArgumentException("Unsupported Typed Object: " + type);
 }
Beispiel #5
0
 // only if this is an object (not primitive) and non null!
 private static void writeRealObject(Object value, Class vClass, OutputStream os)
     throws IOException {
   try {
     if (vClass.equals(String.class)) {
       os.write(0);
       PDataStream.writeUTF((String) value, os);
     } else if (vClass.equals(Integer.class)) {
       os.write(1);
       PDataStream.writeInt(((Integer) value).intValue(), os);
     } else if (vClass.equals(Long.class)) {
       os.write(2);
       PDataStream.writeLong(((Long) value).longValue(), os);
     } else if (vClass.equals(Byte.class)) {
       os.write(3);
       os.write(((Byte) value).byteValue());
     } else if (vClass.equals(Boolean.class)) {
       os.write(4);
       PDataStream.writeBoolean(((Boolean) value).booleanValue(), os);
     } else if (vClass.equals(Character.class)) {
       os.write(5);
       PDataStream.writeChar(((Character) value).charValue(), os);
     } else if (vClass.equals(Short.class)) {
       os.write(6);
       PDataStream.writeShort(((Short) value).shortValue(), os);
     } else if (vClass.equals(Float.class)) {
       os.write(7);
       PDataStream.writeFloat(((Float) value).floatValue(), os);
     } else if (vClass.equals(Double.class)) {
       os.write(8);
       PDataStream.writeDouble(((Double) value).doubleValue(), os);
     } else if (Externalizable.class.isAssignableFrom(vClass)) {
       os.write(11);
       String name = vClass.getName();
       PDataStream.writeUTF(name, os);
       Externalizable tmp = (Externalizable) value;
       tmp.writeObject(os);
     } else {
       os.write(12);
       ObjectOutputStream out = new ObjectOutputStream(os);
       out.writeObject(value);
     }
   } catch (Exception exc) {
     throw new IOException(exc.toString());
   }
 }
 @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();
   }
 }
 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);
  }
 @Override
 public Externalizable read(final ObjectDataInput in) throws IOException {
   final String className = in.readUTF();
   try {
     final Externalizable ds = ClassLoaderUtil.newInstance(in.getClassLoader(), className);
     final ObjectInputStream objectInputStream;
     final InputStream inputStream = (InputStream) in;
     if (gzipEnabled) {
       objectInputStream =
           newObjectInputStream(in.getClassLoader(), new GZIPInputStream(inputStream));
     } else {
       objectInputStream = newObjectInputStream(in.getClassLoader(), inputStream);
     }
     ds.readExternal(objectInputStream);
     return ds;
   } catch (final Exception e) {
     throw new HazelcastSerializationException(
         "Problem while reading Externalizable class : " + className + ", exception: " + e);
   }
 }
 @Override
 public <V> V unmarshall(
     V value,
     PropertyDescriptor propertyDescriptor,
     DataInput dataInput,
     SerializationContext serializationContext)
     throws IOException {
   try {
     ((Externalizable) value).readExternal((ObjectInput) dataInput);
     return value;
   } catch (ClassNotFoundException e) {
     throw new IOException("Error while deserialization", e);
   }
 }
Beispiel #11
0
 public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
   in.readByte(); // ignore version for now
   fieldNumber = in.readShort();
   byte fieldType;
   ISOComponent c;
   try {
     while ((fieldType = in.readByte()) != 'E') {
       c = null;
       switch (fieldType) {
         case 'F':
           c = new ISOField();
           break;
         case 'A':
           c = new ISOAmount();
           break;
         case 'B':
           c = new ISOBinaryField();
           break;
         case 'M':
           c = new ISOMsg();
           break;
         case 'H':
           readHeader(in);
           break;
         case 'P':
           readPackager(in);
           break;
         case 'D':
           readDirection(in);
           break;
         default:
           throw new IOException("malformed ISOMsg");
       }
       if (c != null) {
         ((Externalizable) c).readExternal(in);
         set(c);
       }
     }
   } catch (ISOException e) {
     throw new IOException(e.getMessage());
   }
 }
Beispiel #12
0
 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();
  }