home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / VPage / Java.bin / CLASSES.ZIP / java / io / ObjectStreamClass.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-07-08  |  8.8 KB  |  435 lines
  1. package java.io;
  2.  
  3. import java.security.DigestOutputStream;
  4. import java.security.MessageDigest;
  5. import java.security.NoSuchAlgorithmException;
  6. import sun.misc.Ref;
  7.  
  8. public class ObjectStreamClass implements Serializable {
  9.    private static final int M_TRANSIENT = 128;
  10.    private static final int M_PRIVATE = 2;
  11.    private static final int M_STATIC = 8;
  12.    private static ObjectStreamClassEntry[] descriptorFor = new ObjectStreamClassEntry[61];
  13.    private String name;
  14.    private ObjectStreamClass superclass;
  15.    private boolean serializable;
  16.    private boolean externalizable;
  17.    private ObjectStreamField[] fields;
  18.    private Class ofClass;
  19.    private long suid;
  20.    private int[] fieldSequence;
  21.    private boolean hasWriteObjectMethod;
  22.    private ObjectStreamClass localClassDesc;
  23.    private static Class classSerializable = null;
  24.    private static Class classExternalizable = null;
  25.  
  26.    public static ObjectStreamClass lookup(Class var0) {
  27.       Object var1 = null;
  28.       ObjectStreamClassEntry[] var3 = descriptorFor;
  29.       synchronized(var3){}
  30.  
  31.       ObjectStreamClass var2;
  32.       try {
  33.          ObjectStreamClass var11 = findDescriptorFor(var0);
  34.          if (var11 == null) {
  35.             boolean var5 = classSerializable.isAssignableFrom(var0);
  36.             if (!var5) {
  37.                var2 = null;
  38.                return var2;
  39.             }
  40.  
  41.             boolean var6 = classExternalizable.isAssignableFrom(var0);
  42.             if (var6) {
  43.                var5 = false;
  44.             }
  45.  
  46.             ObjectStreamClass var7 = null;
  47.             if (var5) {
  48.                Class var8 = var0.getSuperclass();
  49.                if (var8 != null) {
  50.                   var7 = lookup(var8);
  51.                }
  52.             }
  53.  
  54.             var11 = new ObjectStreamClass(var0, var7, var5, var6);
  55.             return var11;
  56.          }
  57.  
  58.          var2 = var11;
  59.       } catch (Throwable var10) {
  60.          throw var10;
  61.       }
  62.  
  63.       return var2;
  64.    }
  65.  
  66.    public String getName() {
  67.       return this.name;
  68.    }
  69.  
  70.    public long getSerialVersionUID() {
  71.       return this.suid;
  72.    }
  73.  
  74.    public Class forClass() {
  75.       return this.ofClass;
  76.    }
  77.  
  78.    public String toString() {
  79.       StringBuffer var1 = new StringBuffer();
  80.       var1.append(this.name);
  81.       var1.append(": static final long serialVersionUID = ");
  82.       var1.append(Long.toString(this.suid));
  83.       var1.append("L;");
  84.       return var1.toString();
  85.    }
  86.  
  87.    private ObjectStreamClass(Class var1, ObjectStreamClass var2, boolean var3, boolean var4) {
  88.       this.ofClass = var1;
  89.       this.name = var1.getName();
  90.       this.superclass = var2;
  91.       this.serializable = var3;
  92.       this.externalizable = var4;
  93.       insertDescriptorFor(this);
  94.       if (!this.externalizable && !this.name.equals("java.lang.String")) {
  95.          this.fields = this.getFields0(var1);
  96.          if (this.fields.length > 0) {
  97.             boolean var6;
  98.             do {
  99.                var6 = true;
  100.  
  101.                for(int var5 = this.fields.length - 1; var5 > 0; --var5) {
  102.                   if (this.fields[var5 - 1].compare(this.fields[var5]) > 0) {
  103.                      ObjectStreamField var7 = this.fields[var5];
  104.                      this.fields[var5] = this.fields[var5 - 1];
  105.                      this.fields[var5 - 1] = var7;
  106.                      var6 = false;
  107.                   }
  108.                }
  109.             } while(!var6);
  110.  
  111.             this.computeFieldSequence();
  112.          }
  113.       } else {
  114.          this.fields = new ObjectStreamField[0];
  115.       }
  116.  
  117.       this.suid = getSerialVersionUID(var1);
  118.       if (this.suid == 0L) {
  119.          this.suid = computeSerialVersionUID(var1);
  120.       }
  121.  
  122.       this.hasWriteObjectMethod = hasWriteObject(var1);
  123.    }
  124.  
  125.    ObjectStreamClass(String var1, long var2) {
  126.       this.name = var1;
  127.       this.suid = var2;
  128.       this.superclass = null;
  129.    }
  130.  
  131.    void setClass(Class var1) throws InvalidClassException {
  132.       this.localClassDesc = lookup(var1);
  133.       if (var1.getName().equals(this.name) && this.suid == this.localClassDesc.suid) {
  134.          if (this.serializable == this.localClassDesc.serializable && this.externalizable == this.localClassDesc.externalizable) {
  135.             ObjectStreamField[] var2 = this.localClassDesc.getFields();
  136.             ObjectStreamField[] var3 = this.fields;
  137.             int var4 = 0;
  138.  
  139.             label36:
  140.             for(int var5 = 0; var5 < var3.length; ++var5) {
  141.                for(int var6 = var4; var6 < var2.length; ++var6) {
  142.                   if (var3[var5].name.equals(var2[var6].name)) {
  143.                      if (!var3[var5].typeEquals(var2[var6])) {
  144.                         throw new InvalidClassException(var1.getName(), "The type of field " + var3[var5].name + " of class " + this.name + " is incompatible.");
  145.                      }
  146.  
  147.                      var4 = var6;
  148.                      var3[var5].offset = var2[var6].offset;
  149.                      continue label36;
  150.                   }
  151.                }
  152.  
  153.                var3[var5].offset = -1;
  154.             }
  155.  
  156.             this.computeFieldSequence();
  157.             this.ofClass = var1;
  158.          } else {
  159.             throw new InvalidClassException(var1.getName(), "Serialization incompatible with Externalization");
  160.          }
  161.       } else {
  162.          throw new InvalidClassException(var1.getName(), "Local class not compatible");
  163.       }
  164.    }
  165.  
  166.    boolean typeEquals(ObjectStreamClass var1) {
  167.       return this.suid == var1.suid && this.name.equals(var1.name);
  168.    }
  169.  
  170.    ObjectStreamField[] getFields() {
  171.       return this.fields;
  172.    }
  173.  
  174.    void setSuperclass(ObjectStreamClass var1) {
  175.       this.superclass = var1;
  176.    }
  177.  
  178.    ObjectStreamClass getSuperclass() {
  179.       return this.superclass;
  180.    }
  181.  
  182.    boolean hasWriteObject() {
  183.       return this.hasWriteObjectMethod;
  184.    }
  185.  
  186.    ObjectStreamClass localClassDescriptor() {
  187.       return this.localClassDesc;
  188.    }
  189.  
  190.    boolean isExternalizable() {
  191.       return this.externalizable;
  192.    }
  193.  
  194.    int[] getFieldSequence() {
  195.       return this.fieldSequence;
  196.    }
  197.  
  198.    private void computeFieldSequence() {
  199.       this.fieldSequence = new int[this.fields.length * 2];
  200.  
  201.       for(int var1 = 0; var1 < this.fields.length; ++var1) {
  202.          this.fieldSequence[var1 * 2] = this.fields[var1].type;
  203.          this.fieldSequence[var1 * 2 + 1] = this.fields[var1].offset;
  204.       }
  205.  
  206.    }
  207.  
  208.    private static long computeSerialVersionUID(Class var0) {
  209.       ByteArrayOutputStream var1 = new ByteArrayOutputStream(512);
  210.       long var2 = 0L;
  211.  
  212.       try {
  213.          MessageDigest var4 = MessageDigest.getInstance("SHA");
  214.          DigestOutputStream var5 = new DigestOutputStream(var1, var4);
  215.          DataOutputStream var6 = new DataOutputStream(var5);
  216.          var6.writeUTF(var0.getName());
  217.          int var7 = getClassAccess(var0);
  218.          var7 &= 1553;
  219.          var6.writeInt(var7);
  220.          Class[] var8 = var0.getInterfaces();
  221.          quicksort(var8);
  222.  
  223.          for(int var9 = 0; var9 < var8.length; ++var9) {
  224.             var6.writeUTF(var8[var9].getName());
  225.          }
  226.  
  227.          String[] var10 = getFieldSignatures(var0);
  228.          quicksort(var10);
  229.  
  230.          for(int var11 = 0; var11 < var10.length; ++var11) {
  231.             String var12 = var10[var11];
  232.             int var13 = getFieldAccess(var0, var12);
  233.             if ((var13 & 2) != 2 || (var13 & 128) != 128 && (var13 & 8) != 8) {
  234.                int var14 = var12.indexOf(32);
  235.                String var15 = var12.substring(0, var14);
  236.                String var16 = var12.substring(var14 + 1);
  237.                var6.writeUTF(var15);
  238.                var6.writeInt(var13);
  239.                var6.writeUTF(var16);
  240.             }
  241.          }
  242.  
  243.          String[] var22 = getMethodSignatures(var0);
  244.          quicksort(var22);
  245.  
  246.          for(int var23 = 0; var23 < var22.length; ++var23) {
  247.             String var24 = var22[var23];
  248.             int var26 = getMethodAccess(var0, var24);
  249.             if ((var26 & 2) == 0) {
  250.                int var28 = var24.indexOf(32);
  251.                String var17 = var24.substring(0, var28);
  252.                String var18 = var24.substring(var28 + 1);
  253.                var18 = var18.replace('/', '.');
  254.                var6.writeUTF(var17);
  255.                var6.writeInt(var26);
  256.                var6.writeUTF(var18);
  257.             }
  258.          }
  259.  
  260.          byte[] var25 = var4.digest();
  261.  
  262.          for(int var27 = 0; var27 < Math.min(8, var25.length); ++var27) {
  263.             var2 += (long)(var25[var27] & 255) << var27 * 8;
  264.          }
  265.       } catch (IOException var19) {
  266.          var2 = -1L;
  267.       } catch (NoSuchAlgorithmException var20) {
  268.          throw new SecurityException(((Throwable)var20).getMessage());
  269.       }
  270.  
  271.       return var2;
  272.    }
  273.  
  274.    private static native int getClassAccess(Class var0);
  275.  
  276.    private static native String[] getMethodSignatures(Class var0);
  277.  
  278.    private static native int getMethodAccess(Class var0, String var1);
  279.  
  280.    private static native String[] getFieldSignatures(Class var0);
  281.  
  282.    private static native int getFieldAccess(Class var0, String var1);
  283.  
  284.    void write(ObjectOutputStream var1) throws IOException {
  285.       int var2 = 0;
  286.       if (this.hasWriteObjectMethod) {
  287.          var2 |= 1;
  288.       }
  289.  
  290.       if (this.serializable) {
  291.          var2 |= 2;
  292.       }
  293.  
  294.       if (this.externalizable) {
  295.          var2 |= 4;
  296.       }
  297.  
  298.       var1.writeByte(var2);
  299.       var1.writeShort(this.fields.length);
  300.  
  301.       for(int var3 = 0; var3 < this.fields.length; ++var3) {
  302.          ObjectStreamField var4 = this.fields[var3];
  303.          var1.writeByte(var4.type);
  304.          var1.writeUTF(var4.name);
  305.          if (!var4.isPrimitive()) {
  306.             var1.writeObject(var4.typeString);
  307.          }
  308.       }
  309.  
  310.    }
  311.  
  312.    void read(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  313.       byte var2 = var1.readByte();
  314.       this.hasWriteObjectMethod = (var2 & 1) != 0;
  315.       this.serializable = (var2 & 2) != 0;
  316.       this.externalizable = (var2 & 4) != 0;
  317.       short var3 = var1.readShort();
  318.       this.fields = new ObjectStreamField[var3];
  319.  
  320.       for(int var4 = 0; var4 < var3; ++var4) {
  321.          char var5 = (char)var1.readByte();
  322.          String var6 = var1.readUTF();
  323.          String var7 = null;
  324.          if (var5 == '[' || var5 == 'L') {
  325.             var7 = (String)var1.readObject();
  326.          }
  327.  
  328.          this.fields[var4] = new ObjectStreamField(var6, var5, -1, var7);
  329.       }
  330.  
  331.    }
  332.  
  333.    private static ObjectStreamClass findDescriptorFor(Class var0) {
  334.       int var1 = var0.hashCode();
  335.  
  336.       ObjectStreamClassEntry var3;
  337.       for(int var2 = (var1 & Integer.MAX_VALUE) % descriptorFor.length; (var3 = descriptorFor[var2]) != null && ((Ref)var3).check() == null; descriptorFor[var2] = var3.next) {
  338.       }
  339.  
  340.       for(ObjectStreamClassEntry var4 = var3; var3 != null; var3 = var3.next) {
  341.          ObjectStreamClass var5 = (ObjectStreamClass)((Ref)var3).check();
  342.          if (var5 == null) {
  343.             var4.next = var3.next;
  344.          } else {
  345.             if (var5.ofClass == var0) {
  346.                return var5;
  347.             }
  348.  
  349.             var4 = var3;
  350.          }
  351.       }
  352.  
  353.       return null;
  354.    }
  355.  
  356.    private static void insertDescriptorFor(ObjectStreamClass var0) {
  357.       if (findDescriptorFor(var0.ofClass) == null) {
  358.          int var1 = var0.ofClass.hashCode();
  359.          int var2 = (var1 & Integer.MAX_VALUE) % descriptorFor.length;
  360.          ObjectStreamClassEntry var3 = new ObjectStreamClassEntry();
  361.          ((Ref)var3).setThing(var0);
  362.          var3.next = descriptorFor[var2];
  363.          descriptorFor[var2] = var3;
  364.       }
  365.    }
  366.  
  367.    private native ObjectStreamField[] getFields0(Class var1);
  368.  
  369.    private static native long getSerialVersionUID(Class var0);
  370.  
  371.    private static native boolean hasWriteObject(Class var0);
  372.  
  373.    private static int doCompare(Object var0, Object var1) {
  374.       String var2;
  375.       String var3;
  376.       if (var0 instanceof String && var1 instanceof String) {
  377.          var2 = (String)var0;
  378.          var3 = (String)var1;
  379.       } else if (var0 instanceof Class && var1 instanceof Class) {
  380.          Class var6 = (Class)var0;
  381.          Class var7 = (Class)var1;
  382.          var2 = var6.getName();
  383.          var3 = var7.getName();
  384.       } else {
  385.          if (!(var0 instanceof ObjectStreamField) || !(var1 instanceof ObjectStreamField)) {
  386.             throw new Error("Unsupported types");
  387.          }
  388.  
  389.          ObjectStreamField var4 = (ObjectStreamField)var0;
  390.          ObjectStreamField var5 = (ObjectStreamField)var1;
  391.          var2 = var4.name;
  392.          var3 = var5.name;
  393.       }
  394.  
  395.       return var2.compareTo(var3);
  396.    }
  397.  
  398.    private static void swap(Object[] var0, int var1, int var2) {
  399.       Object var3 = var0[var1];
  400.       var0[var1] = var0[var2];
  401.       var0[var2] = var3;
  402.    }
  403.  
  404.    private static void quicksort(Object[] var0, int var1, int var2) {
  405.       if (var1 < var2) {
  406.          swap(var0, var1, (var1 + var2) / 2);
  407.          int var4 = var1;
  408.  
  409.          for(int var3 = var1 + 1; var3 <= var2; ++var3) {
  410.             if (doCompare(var0[var3], var0[var1]) < 0) {
  411.                ++var4;
  412.                swap(var0, var4, var3);
  413.             }
  414.          }
  415.  
  416.          swap(var0, var1, var4);
  417.          quicksort(var0, var1, var4 - 1);
  418.          quicksort(var0, var4 + 1, var2);
  419.       }
  420.    }
  421.  
  422.    private static void quicksort(Object[] var0) {
  423.       quicksort(var0, 0, var0.length - 1);
  424.    }
  425.  
  426.    static {
  427.       try {
  428.          classSerializable = Class.forName("java.io.Serializable");
  429.          classExternalizable = Class.forName("java.io.Externalizable");
  430.       } catch (Throwable var0) {
  431.          System.err.println("Could not load java.io.Serializable or java.io.Externalizable.");
  432.       }
  433.    }
  434. }
  435.