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