PC Pro 1999 April/DPPCPRO0499.ISO/April/Notes/50b2wic.exe/DATA1.CAB/NotesProgramFilesJavaSupport/rt.jar/java/io/ObjectStreamClass.class

Java Class File | 1998-04-23 | 10.0 KB | 485 lines

package java.io;

import java.security.DigestOutputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import sun.misc.Ref;

public class ObjectStreamClass implements Serializable {
   static final long serialVersionUID = -6120832682080437368L;
   private static final int M_TRANSIENT = 128;
   private static final int M_PRIVATE = 2;
   private static final int M_STATIC = 8;
   private static ObjectStreamClassEntry[] descriptorFor = new ObjectStreamClassEntry[61];
   private String name;
   private ObjectStreamClass superclass;
   private boolean serializable;
   private boolean externalizable;
   private ObjectStreamField[] fields;
   private Class ofClass;
   private long suid;
   private int[] fieldSequence;
   private boolean hasWriteObjectMethod;
   private boolean hasExternalizableBlockData;
   private ObjectStreamClass localClassDesc;
   private static Class classSerializable = null;
   private static Class classExternalizable = null;

   public static ObjectStreamClass lookup(Class var0) {
      Object var1 = null;
      ObjectStreamClassEntry[] var3 = descriptorFor;
      synchronized(var3){}

      ObjectStreamClass var2;
      try {
         ObjectStreamClass var11 = findDescriptorFor(var0);
         if (var11 == null) {
            boolean var5 = classSerializable.isAssignableFrom(var0);
            if (!var5) {
               var2 = null;
               return var2;
            }

            boolean var6 = classExternalizable.isAssignableFrom(var0);
            if (var6) {
               var5 = false;
            }

            ObjectStreamClass var7 = null;
            if (var5) {
               Class var8 = var0.getSuperclass();
               if (var8 != null) {
                  var7 = lookup(var8);
               }
            }

            var11 = new ObjectStreamClass(var0, var7, var5, var6);
            return var11;
         }

         var2 = var11;
      } catch (Throwable var10) {
         throw var10;
      }

      return var2;
   }

   public String getName() {
      return this.name;
   }

   public long getSerialVersionUID() {
      return this.suid;
   }

   public Class forClass() {
      return this.ofClass;
   }

   public String toString() {
      StringBuffer var1 = new StringBuffer();
      var1.append(this.name);
      var1.append(": static final long serialVersionUID = ");
      var1.append(Long.toString(this.suid));
      var1.append("L;");
      return var1.toString();
   }

   private ObjectStreamClass(Class var1, ObjectStreamClass var2, boolean var3, boolean var4) {
      this.ofClass = var1;
      this.name = var1.getName();
      this.superclass = var2;
      this.serializable = var3;
      this.externalizable = var4;
      insertDescriptorFor(this);
      if (!this.externalizable && !this.name.equals("java.lang.String")) {
         this.fields = this.getFields0(var1);
         if (this.fields.length > 0) {
            boolean var6;
            do {
               var6 = true;

               for(int var5 = this.fields.length - 1; var5 > 0; --var5) {
                  if (this.fields[var5 - 1].compare(this.fields[var5]) > 0) {
                     ObjectStreamField var7 = this.fields[var5];
                     this.fields[var5] = this.fields[var5 - 1];
                     this.fields[var5 - 1] = var7;
                     var6 = false;
                  }
               }
            } while(!var6);

            this.computeFieldSequence();
         }
      } else {
         this.fields = new ObjectStreamField[0];
      }

      this.suid = getSerialVersionUID(var1);
      if (this.suid == 0L) {
         this.suid = computeSerialVersionUID(var1);
      }

      this.hasWriteObjectMethod = hasWriteObject(var1);
   }

   ObjectStreamClass(String var1, long var2) {
      this.name = var1;
      this.suid = var2;
      this.superclass = null;
   }

   void setClass(Class var1) throws InvalidClassException {
      if (var1 == null) {
         this.localClassDesc = null;
         this.ofClass = null;

         for(int var7 = 0; var7 < this.fields.length; ++var7) {
            this.fields[var7].offset = -1;
         }

         this.computeFieldSequence();
      } else {
         this.localClassDesc = lookup(var1);
         if (this.localClassDesc == null) {
            throw new InvalidClassException(var1.getName(), "Local class not compatible");
         } else if (this.suid == this.localClassDesc.suid || var1.isArray() && !var1.getName().equals(this.name)) {
            if (!compareClassNames(this.name, var1.getName(), '.')) {
               throw new InvalidClassException(this.name, "Incompatible local class name: " + var1.getName());
            } else if (this.serializable == this.localClassDesc.serializable && this.externalizable == this.localClassDesc.externalizable) {
               ObjectStreamField[] var2 = this.localClassDesc.getFields();
               ObjectStreamField[] var3 = this.fields;
               int var4 = 0;

               label54:
               for(int var5 = 0; var5 < var3.length; ++var5) {
                  for(int var6 = var4; var6 < var2.length; ++var6) {
                     if (var3[var5].name.equals(var2[var6].name)) {
                        if (!var3[var5].typeEquals(var2[var6])) {
                           throw new InvalidClassException(var1.getName(), "The type of field " + var3[var5].name + " of class " + this.name + " is incompatible.");
                        }

                        var4 = var6;
                        var3[var5].offset = var2[var6].offset;
                        continue label54;
                     }
                  }

                  var3[var5].offset = -1;
               }

               this.computeFieldSequence();
               this.ofClass = var1;
            } else {
               throw new InvalidClassException(var1.getName(), "Serialization incompatible with Externalization");
            }
         } else {
            throw new InvalidClassException(var1.getName(), "Local class not compatible: stream classdesc serialVersionUID=" + this.suid + " local class serialVersionUID=" + this.localClassDesc.suid);
         }
      }
   }

   static boolean compareClassNames(String var0, String var1, char var2) {
      int var3 = var0.lastIndexOf(var2);
      if (var3 < 0) {
         var3 = 0;
      }

      int var4 = var1.lastIndexOf(var2);
      if (var4 < 0) {
         var4 = 0;
      }

      boolean var5 = var0.regionMatches(false, var3, var1, var4, var0.length() - var3);
      return var5;
   }

   boolean typeEquals(ObjectStreamClass var1) {
      return this.suid == var1.suid && compareClassNames(this.name, var1.name, '.');
   }

   ObjectStreamField[] getFields() {
      return this.fields;
   }

   void setSuperclass(ObjectStreamClass var1) {
      this.superclass = var1;
   }

   ObjectStreamClass getSuperclass() {
      return this.superclass;
   }

   boolean hasWriteObject() {
      return this.hasWriteObjectMethod;
   }

   boolean hasExternalizableBlockDataMode() {
      return this.hasExternalizableBlockData;
   }

   ObjectStreamClass localClassDescriptor() {
      return this.localClassDesc;
   }

   boolean isExternalizable() {
      return this.externalizable;
   }

   int[] getFieldSequence() {
      return this.fieldSequence;
   }

   private void computeFieldSequence() {
      this.fieldSequence = new int[this.fields.length * 2];

      for(int var1 = 0; var1 < this.fields.length; ++var1) {
         this.fieldSequence[var1 * 2] = this.fields[var1].type;
         this.fieldSequence[var1 * 2 + 1] = this.fields[var1].offset;
      }

   }

   private static long computeSerialVersionUID(Class var0) {
      ByteArrayOutputStream var1 = new ByteArrayOutputStream(512);
      long var2 = 0L;

      try {
         MessageDigest var4 = MessageDigest.getInstance("SHA");
         DigestOutputStream var5 = new DigestOutputStream(var1, var4);
         DataOutputStream var6 = new DataOutputStream(var5);
         var6.writeUTF(var0.getName());
         int var7 = getClassAccess(var0);
         var7 &= 1553;
         var6.writeInt(var7);
         Class[] var8 = var0.getInterfaces();
         quicksort(var8);

         for(int var9 = 0; var9 < var8.length; ++var9) {
            var6.writeUTF(var8[var9].getName());
         }

         String[] var10 = getFieldSignatures(var0);
         quicksort(var10);

         for(int var11 = 0; var11 < var10.length; ++var11) {
            String var12 = var10[var11];
            int var13 = getFieldAccess(var0, var12);
            if ((var13 & 2) != 2 || (var13 & 128) != 128 && (var13 & 8) != 8) {
               int var14 = var12.indexOf(32);
               String var15 = var12.substring(0, var14);
               String var16 = var12.substring(var14 + 1);
               var6.writeUTF(var15);
               var6.writeInt(var13);
               var6.writeUTF(var16);
            }
         }

         String[] var22 = getMethodSignatures(var0);
         quicksort(var22);

         for(int var23 = 0; var23 < var22.length; ++var23) {
            String var24 = var22[var23];
            int var26 = getMethodAccess(var0, var24);
            if ((var26 & 2) == 0) {
               int var28 = var24.indexOf(32);
               String var17 = var24.substring(0, var28);
               String var18 = var24.substring(var28 + 1);
               var18 = var18.replace('/', '.');
               var6.writeUTF(var17);
               var6.writeInt(var26);
               var6.writeUTF(var18);
            }
         }

         byte[] var25 = var4.digest();

         for(int var27 = 0; var27 < Math.min(8, var25.length); ++var27) {
            var2 += (long)(var25[var27] & 255) << var27 * 8;
         }
      } catch (IOException var19) {
         var2 = -1L;
      } catch (NoSuchAlgorithmException var20) {
         throw new SecurityException(((Throwable)var20).getMessage());
      }

      return var2;
   }

   private static native int getClassAccess(Class var0);

   private static native String[] getMethodSignatures(Class var0);

   private static native int getMethodAccess(Class var0, String var1);

   private static native String[] getFieldSignatures(Class var0);

   private static native int getFieldAccess(Class var0, String var1);

   void write(ObjectOutputStream var1) throws IOException {
      int var2 = 0;
      if (this.hasWriteObjectMethod) {
         var2 |= 1;
      }

      if (this.serializable) {
         var2 |= 2;
      }

      if (this.externalizable) {
         var2 |= 4;
      }

      var1.writeByte(var2);
      var1.writeShort(this.fields.length);
      boolean var3 = var1.enableReplace;
      var1.enableReplace = false;

      try {
         for(int var6 = 0; var6 < this.fields.length; ++var6) {
            ObjectStreamField var7 = this.fields[var6];
            var1.writeByte(var7.type);
            var1.writeUTF(var7.name);
            if (!var7.isPrimitive()) {
               var1.writeObject(var7.typeString);
            }
         }
      } finally {
         var1.enableReplace = var3;
      }

   }

   void read(ObjectInputStream var1) throws IOException, ClassNotFoundException {
      byte var2 = var1.readByte();
      this.serializable = (var2 & 2) != 0;
      this.externalizable = (var2 & 4) != 0;
      this.hasWriteObjectMethod = this.serializable ? (var2 & 1) != 0 : false;
      byte var3 = 1;
      this.hasExternalizableBlockData = this.externalizable ? (var2 & var3) != 0 : false;
      short var4 = var1.readShort();
      this.fields = new ObjectStreamField[var4];
      boolean var5 = var1.enableResolve;
      var1.enableResolve = false;

      try {
         for(int var8 = 0; var8 < var4; ++var8) {
            char var9 = (char)var1.readByte();
            String var10 = var1.readUTF();
            String var11 = null;
            if (var9 == '[' || var9 == 'L') {
               var11 = (String)var1.readObject();
            }

            this.fields[var8] = new ObjectStreamField(var10, var9, -1, var11);
         }
      } finally {
         var1.enableResolve = var5;
      }

   }

   private static ObjectStreamClass findDescriptorFor(Class var0) {
      int var1 = var0.hashCode();

      ObjectStreamClassEntry var3;
      for(int var2 = (var1 & Integer.MAX_VALUE) % descriptorFor.length; (var3 = descriptorFor[var2]) != null && ((Ref)var3).check() == null; descriptorFor[var2] = var3.next) {
      }

      for(ObjectStreamClassEntry var4 = var3; var3 != null; var3 = var3.next) {
         ObjectStreamClass var5 = (ObjectStreamClass)((Ref)var3).check();
         if (var5 == null) {
            var4.next = var3.next;
         } else {
            if (var5.ofClass == var0) {
               return var5;
            }

            var4 = var3;
         }
      }

      return null;
   }

   private static void insertDescriptorFor(ObjectStreamClass var0) {
      if (findDescriptorFor(var0.ofClass) == null) {
         int var1 = var0.ofClass.hashCode();
         int var2 = (var1 & Integer.MAX_VALUE) % descriptorFor.length;
         ObjectStreamClassEntry var3 = new ObjectStreamClassEntry();
         ((Ref)var3).setThing(var0);
         var3.next = descriptorFor[var2];
         descriptorFor[var2] = var3;
      }
   }

   private native ObjectStreamField[] getFields0(Class var1);

   private static native long getSerialVersionUID(Class var0);

   private static native boolean hasWriteObject(Class var0);

   private static int doCompare(Object var0, Object var1) {
      String var2;
      String var3;
      if (var0 instanceof String && var1 instanceof String) {
         var2 = (String)var0;
         var3 = (String)var1;
      } else if (var0 instanceof Class && var1 instanceof Class) {
         Class var6 = (Class)var0;
         Class var7 = (Class)var1;
         var2 = var6.getName();
         var3 = var7.getName();
      } else {
         if (!(var0 instanceof ObjectStreamField) || !(var1 instanceof ObjectStreamField)) {
            throw new Error("Unsupported types");
         }

         ObjectStreamField var4 = (ObjectStreamField)var0;
         ObjectStreamField var5 = (ObjectStreamField)var1;
         var2 = var4.name;
         var3 = var5.name;
      }

      return var2.compareTo(var3);
   }

   private static void swap(Object[] var0, int var1, int var2) {
      Object var3 = var0[var1];
      var0[var1] = var0[var2];
      var0[var2] = var3;
   }

   private static void quicksort(Object[] var0, int var1, int var2) {
      if (var1 < var2) {
         swap(var0, var1, (var1 + var2) / 2);
         int var4 = var1;

         for(int var3 = var1 + 1; var3 <= var2; ++var3) {
            if (doCompare(var0[var3], var0[var1]) < 0) {
               ++var4;
               swap(var0, var4, var3);
            }
         }

         swap(var0, var1, var4);
         quicksort(var0, var1, var4 - 1);
         quicksort(var0, var4 + 1, var2);
      }
   }

   private static void quicksort(Object[] var0) {
      quicksort(var0, 0, var0.length - 1);
   }

   static {
      try {
         classSerializable = Class.forName("java.io.Serializable");
         classExternalizable = Class.forName("java.io.Externalizable");
      } catch (Throwable var0) {
         System.err.println("Could not load java.io.Serializable or java.io.Externalizable.");
      }
   }
}