Example #1
0
  /**
   * Deserializes an object from the given stream.
   *
   * @param in the data input stream, from which the object is deserialized
   * @return the serializable object
   * @throws IOException when serialization data could not be read or the Serializable class could
   *     not get instantiated
   */
  public static Object deserialize(DataInputStream in) throws IOException {
    byte version = in.readByte();
    // #if polish.debug.warn
    if (version > VERSION) {
      // #debug warn
      System.out.println(
          "Warning: trying to deserialize class that has been serialized with a newer version ("
              + version
              + ">"
              + VERSION
              + ").");
    }
    // #endif
    boolean isNull = in.readBoolean();
    if (isNull) {
      return null;
    }
    byte type = in.readByte();
    switch (type) {
      case TYPE_EXTERNALIZABLE:
        String className = in.readUTF();
        // #if polish.JavaSE
        if (obfuscationDeserializeMap != null) {
          String fullClassName = (String) obfuscationDeserializeMap.get(className);
          if (fullClassName != null) {
            // System.out.println("Serializer.deserialize: translating classname from " + className
            // + " to " +  fullClassName );
            className = fullClassName;
          }
        }
        // #endif
        // #debug debug
        // #= System.out.println("deserialize " + className + "...");
        Externalizable extern = null;
        try {
          extern = (Externalizable) Class.forName(className).newInstance();
        } catch (Exception e) {
          // #debug error
          System.out.println("Unable to instantiate serializable \"" + className + "\"" + e);
          throw new IOException(e.toString());
        }
        extern.read(in);
        return extern;
      case TYPE_EXTERNALIZABLE_ARRAY:
        String cn = in.readUTF();
        // #if polish.JavaSE
        if (obfuscationDeserializeMap != null) {
          String fullClassName = (String) obfuscationDeserializeMap.get(cn);
          if (fullClassName != null) {
            // System.out.println("Serializer.deserialize: translating classname from " + cn + " to
            // " +  fullClassName );
            cn = fullClassName;
          }
        }
        // #endif

        int length = in.readInt();
        Externalizable[] externalizables;

        // #if !polish.JavaSE
        externalizables = new Externalizable[length];
        // #else
        try {
          // #if false
          externalizables = null;
          // #else
          // # externalizables = (Externalizable[]) Array.newInstance(Class.forName( cn ), length);
          // #endif
        } catch (Exception e) {
          // #debug error
          System.out.println("Unable to instantiate Serializable \"" + cn + "\"" + e);
          throw new IOException(e.toString());
        }
        // #endif

        Class[] classes = new Class[Math.min(length, 7)];
        Class currentClass;
        byte idCounter = 0;
        for (int i = 0; i < externalizables.length; i++) {
          int classId = in.readByte();
          if (classId == 0) { // new class name
            className = in.readUTF();
            // #if polish.JavaSE
            if (obfuscationDeserializeMap != null) {
              String fullClassName = (String) obfuscationDeserializeMap.get(className);
              if (fullClassName != null) {
                // System.out.println("Serializer.deserialize: translating classname from " +
                // className + " to " +  fullClassName );
                className = fullClassName;
              }
            }
            // #endif
            try {
              currentClass = Class.forName(className);
            } catch (ClassNotFoundException e) {
              // #debug error
              System.out.println("Unable to load Serializable class \"" + className + "\"" + e);
              throw new IOException(e.toString());
            }
            if (idCounter > classes.length) {
              Class[] newClasses = new Class[classes.length + 7];
              System.arraycopy(classes, 0, newClasses, 0, classes.length);
              classes = newClasses;
            }
            classes[idCounter] = currentClass;
            idCounter++;
          } else {
            currentClass = classes[classId - 1];
          }
          Externalizable externalizable;
          try {
            externalizable = (Externalizable) currentClass.newInstance();
            externalizable.read(in);
            externalizables[i] = externalizable;
          } catch (Exception e) {
            // #debug error
            System.out.println(
                "Unable to instantiate Serializable \"" + currentClass.getName() + "\"" + e);
            throw new IOException(e.toString());
          }
        }
        return externalizables;
      case TYPE_OBJECT_ARRAY:
        length = in.readInt();
        Object[] objects = new Object[length];
        for (int i = 0; i < objects.length; i++) {
          objects[i] = deserialize(in);
        }
        return objects;
      case TYPE_BYTE:
        return new Byte(in.readByte());
      case TYPE_SHORT:
        return new Short(in.readShort());
      case TYPE_INTEGER:
        return new Integer(in.readInt());
      case TYPE_LONG:
        return new Long(in.readLong());
        // #if polish.hasFloatingPoint
      case TYPE_FLOAT:
        return new Float(in.readFloat());
      case TYPE_DOUBLE:
        return new Double(in.readDouble());
        // #endif
      case TYPE_STRING:
        return in.readUTF();
      case TYPE_STRING_BUFFER:
        return new StringBuffer(in.readUTF());
      case TYPE_CHARACTER:
        return new Character(in.readChar());
      case TYPE_BOOLEAN:
        return new Boolean(in.readBoolean());
      case TYPE_DATE:
        return new Date(in.readLong());
      case TYPE_CALENDAR:
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date(in.readLong()));
        return calendar;
      case TYPE_RANDOM:
        return new Random();
      case TYPE_HASHTABLE:
        int size = in.readInt();
        Hashtable hashtable = new Hashtable(size);
        for (int i = 0; i < size; i++) {
          Object key = deserialize(in);
          Object value = deserialize(in);
          hashtable.put(key, value);
        }
        return hashtable;
      case TYPE_STACK:
      case TYPE_VECTOR:
        size = in.readInt();
        Vector vector;
        if (type == TYPE_STACK) {
          vector = new Stack();
        } else {
          vector = new Vector(size);
        }
        for (int i = 0; i < size; i++) {
          Object value = deserialize(in);
          vector.addElement(value);
        }
        return vector;
        // #if polish.midp2
      case TYPE_IMAGE:
        byte subType = in.readByte();
        if (subType == TYPE_IMAGE_RGB) {
          int width = in.readInt();
          int height = in.readInt();
          int[] rgb = new int[width * height];
          for (int i = 0; i < rgb.length; i++) {
            rgb[i] = in.readInt();
          }
          return Image.createRGBImage(rgb, width, height, true);
        }

        // this is a bytes based format like png:
        int bytesLength = in.readInt();
        byte[] buffer = new byte[bytesLength];
        in.readFully(buffer);
        return Image.createImage(buffer, 0, bytesLength);
        // #endif
        // #if polish.midp
      case TYPE_FONT:
        int face = in.readInt();
        int style = in.readInt();
        size = in.readInt();
        return Font.getFont(face, style, size);
      case TYPE_COMMAND:
        int cmdType = in.readInt();
        int priority = in.readInt();
        String label = in.readUTF();
        return new Command(label, cmdType, priority);
        // #endif
      case TYPE_BYTE_ARRAY:
        length = in.readInt();
        byte[] byteNumbers = new byte[length];
        in.readFully(byteNumbers);
        return byteNumbers;
      case TYPE_SHORT_ARRAY:
        length = in.readInt();
        short[] shortNumbers = new short[length];
        for (int i = 0; i < length; i++) {
          shortNumbers[i] = in.readShort();
        }
        return shortNumbers;
      case TYPE_INT_ARRAY:
        length = in.readInt();
        int[] intNumbers = new int[length];
        for (int i = 0; i < length; i++) {
          intNumbers[i] = in.readInt();
        }
        return intNumbers;
      case TYPE_LONG_ARRAY:
        length = in.readInt();
        long[] longNumbers = new long[length];
        for (int i = 0; i < length; i++) {
          longNumbers[i] = in.readLong();
        }
        return longNumbers;
        // #if polish.hasFloatingPoint
      case TYPE_FLOAT_ARRAY:
        length = in.readInt();
        float[] floatNumbers = new float[length];
        for (int i = 0; i < length; i++) {
          floatNumbers[i] = in.readFloat();
        }
        return floatNumbers;
      case TYPE_DOUBLE_ARRAY:
        length = in.readInt();
        double[] doubleNumbers = new double[length];
        for (int i = 0; i < length; i++) {
          doubleNumbers[i] = in.readDouble();
        }
        return doubleNumbers;
        // #endif
      case TYPE_CHAR_ARRAY:
        length = in.readInt();
        char[] characters = new char[length];
        for (int i = 0; i < length; i++) {
          characters[i] = in.readChar();
        }
        return characters;
      case TYPE_BOOLEAN_ARRAY:
        length = in.readInt();
        boolean[] bools = new boolean[length];
        for (int i = 0; i < length; i++) {
          bools[i] = in.readBoolean();
        }
        return bools;
      case TYPE_STRING_ARRAY:
        length = in.readInt();
        String[] strings = new String[length];
        for (int i = 0; i < length; i++) {
          strings[i] = in.readUTF();
        }
        return strings;
      default:
        throw new IOException("Unknown type: " + type);
    }
  }
Example #2
0
 /**
  * Reads an object directly from a byte array
  *
  * @param data the serialized data
  * @return the original object
  * @throws IOException when serialization fails
  * @see #serialize(Object, boolean)
  */
 public static void deserialize(byte[] data, Externalizable object) throws IOException {
   ByteArrayInputStream byteIn = new ByteArrayInputStream(data);
   DataInputStream in = new DataInputStream(byteIn);
   object.read(in);
 }