@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);
   }
 }
 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);
  }
Beispiel #4
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);
  }
 @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();
   }
 }
Beispiel #6
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();
  }