home *** CD-ROM | disk | FTP | other *** search
/ Dynamic HTML Construction Kit / Dynamic HTML Construction Kit.iso / earthlink / nscomm / java40.jar / netscape / util / Hashtable.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-11-03  |  4.6 KB  |  383 lines
  1. package netscape.util;
  2.  
  3. public class Hashtable implements Cloneable, Codable {
  4.    // $FF: renamed from: A int
  5.    static final int field_0 = -1640531527;
  6.    static final int EMPTY = 0;
  7.    static final int REMOVED = 1;
  8.    static final int DEFAULT = 2;
  9.    static final String keysField = "keys";
  10.    static final String elementsField = "elements";
  11.    int count;
  12.    int totalCount;
  13.    int shift;
  14.    int capacity;
  15.    int indexMask;
  16.    int[] hashCodes;
  17.    Object[] keys;
  18.    Object[] elements;
  19.  
  20.    public Hashtable() {
  21.       this.shift = 30;
  22.    }
  23.  
  24.    public Hashtable(int var1) {
  25.       this();
  26.       if (var1 < 0) {
  27.          throw new IllegalArgumentException("initialCapacity must be > 0");
  28.       } else {
  29.          this.grow(var1);
  30.       }
  31.    }
  32.  
  33.    public Object clone() {
  34.       Hashtable var2;
  35.       try {
  36.          var2 = (Hashtable)super.clone();
  37.       } catch (CloneNotSupportedException var3) {
  38.          throw new InternalError("Error in clone(). This shouldn't happen.");
  39.       }
  40.  
  41.       if (this.count == 0) {
  42.          var2.shift = 30;
  43.          var2.totalCount = 0;
  44.          var2.capacity = 0;
  45.          var2.indexMask = 0;
  46.          var2.hashCodes = null;
  47.          var2.keys = null;
  48.          var2.elements = null;
  49.          return var2;
  50.       } else {
  51.          int var1 = this.hashCodes.length;
  52.          var2.hashCodes = new int[var1];
  53.          var2.keys = new Object[var1];
  54.          var2.elements = new Object[var1];
  55.          System.arraycopy(this.hashCodes, 0, var2.hashCodes, 0, var1);
  56.          System.arraycopy(this.keys, 0, var2.keys, 0, var1);
  57.          System.arraycopy(this.elements, 0, var2.elements, 0, var1);
  58.          return var2;
  59.       }
  60.    }
  61.  
  62.    public int count() {
  63.       return this.count;
  64.    }
  65.  
  66.    public int size() {
  67.       return this.count;
  68.    }
  69.  
  70.    public boolean isEmpty() {
  71.       return this.count == 0;
  72.    }
  73.  
  74.    public Enumeration keys() {
  75.       return new HashtableEnumerator(this, true);
  76.    }
  77.  
  78.    public Enumeration elements() {
  79.       return new HashtableEnumerator(this, false);
  80.    }
  81.  
  82.    public Vector keysVector() {
  83.       if (this.count == 0) {
  84.          return new Vector();
  85.       } else {
  86.          Vector var4 = new Vector(this.count);
  87.          int var2 = 0;
  88.  
  89.          for(int var1 = 0; var1 < this.keys.length && var2 < this.count; ++var1) {
  90.             Object var3 = this.keys[var1];
  91.             if (var3 != null) {
  92.                var4.addElement(var3);
  93.                ++var2;
  94.             }
  95.          }
  96.  
  97.          return var4;
  98.       }
  99.    }
  100.  
  101.    public Vector elementsVector() {
  102.       if (this.count == 0) {
  103.          return new Vector();
  104.       } else {
  105.          Vector var4 = new Vector(this.count);
  106.          int var2 = 0;
  107.  
  108.          for(int var1 = 0; var1 < this.elements.length && var2 < this.count; ++var1) {
  109.             Object var3 = this.elements[var1];
  110.             if (var3 != null) {
  111.                var4.addElement(var3);
  112.                ++var2;
  113.             }
  114.          }
  115.  
  116.          return var4;
  117.       }
  118.    }
  119.  
  120.    public Object[] keysArray() {
  121.       if (this.count == 0) {
  122.          return null;
  123.       } else {
  124.          Object[] var4 = new Object[this.count];
  125.          int var2 = 0;
  126.  
  127.          for(int var1 = 0; var1 < this.keys.length && var2 < this.count; ++var1) {
  128.             Object var3 = this.keys[var1];
  129.             if (var3 != null) {
  130.                var4[var2++] = var3;
  131.             }
  132.          }
  133.  
  134.          return var4;
  135.       }
  136.    }
  137.  
  138.    public Object[] elementsArray() {
  139.       if (this.count == 0) {
  140.          return null;
  141.       } else {
  142.          Object[] var4 = new Object[this.count];
  143.          int var2 = 0;
  144.  
  145.          for(int var1 = 0; var1 < this.elements.length && var2 < this.count; ++var1) {
  146.             Object var3 = this.elements[var1];
  147.             if (var3 != null) {
  148.                var4[var2++] = var3;
  149.             }
  150.          }
  151.  
  152.          return var4;
  153.       }
  154.    }
  155.  
  156.    public boolean contains(Object var1) {
  157.       if (this.count == 0) {
  158.          return false;
  159.       } else if (var1 == null) {
  160.          throw new NullPointerException();
  161.       } else if (this.elements == null) {
  162.          return false;
  163.       } else {
  164.          for(int var2 = 0; var2 < this.elements.length; ++var2) {
  165.             Object var3 = this.elements[var2];
  166.             if (var3 != null && var1.equals(var3)) {
  167.                return true;
  168.             }
  169.          }
  170.  
  171.          return false;
  172.       }
  173.    }
  174.  
  175.    public boolean containsKey(Object var1) {
  176.       return this.get(var1) != null;
  177.    }
  178.  
  179.    public Object get(Object var1) {
  180.       return this.count == 0 ? null : this.elements[this.tableIndexFor(var1, this.hash(var1))];
  181.    }
  182.  
  183.    public Object remove(Object var1) {
  184.       if (this.count == 0) {
  185.          return null;
  186.       } else {
  187.          int var2 = this.tableIndexFor(var1, this.hash(var1));
  188.          Object var3 = this.elements[var2];
  189.          if (var3 == null) {
  190.             return null;
  191.          } else {
  192.             --this.count;
  193.             this.hashCodes[var2] = 1;
  194.             this.keys[var2] = null;
  195.             this.elements[var2] = null;
  196.             return var3;
  197.          }
  198.       }
  199.    }
  200.  
  201.    public Object put(Object var1, Object var2) {
  202.       if (var2 == null) {
  203.          throw new NullPointerException();
  204.       } else {
  205.          if (this.hashCodes == null) {
  206.             this.grow();
  207.          }
  208.  
  209.          int var4 = this.hash(var1);
  210.          int var3 = this.tableIndexFor(var1, var4);
  211.          Object var5 = this.elements[var3];
  212.          if (var5 == null) {
  213.             if (this.hashCodes[var3] == 0) {
  214.                if (this.totalCount >= this.capacity) {
  215.                   this.grow();
  216.                   return this.put(var1, var2);
  217.                }
  218.  
  219.                ++this.totalCount;
  220.             }
  221.  
  222.             ++this.count;
  223.          }
  224.  
  225.          this.hashCodes[var3] = var4;
  226.          this.keys[var3] = var1;
  227.          this.elements[var3] = var2;
  228.          return var5;
  229.       }
  230.    }
  231.  
  232.    private int hash(Object var1) {
  233.       int var2 = var1.hashCode();
  234.       if (var2 == 0 || var2 == 1) {
  235.          var2 = 2;
  236.       }
  237.  
  238.       return var2;
  239.    }
  240.  
  241.    private int tableIndexFor(Object var1, int var2) {
  242.       int var3 = var2 * -1640531527;
  243.       int var5 = var3 >>> this.shift;
  244.       int var4 = this.hashCodes[var5];
  245.       int var7;
  246.       if (var4 == var2) {
  247.          if (var1.equals(this.keys[var5])) {
  248.             return var5;
  249.          }
  250.  
  251.          var7 = -1;
  252.       } else {
  253.          if (var4 == 0) {
  254.             return var5;
  255.          }
  256.  
  257.          if (var4 == 1) {
  258.             var7 = var5;
  259.          } else {
  260.             var7 = -1;
  261.          }
  262.       }
  263.  
  264.       int var6 = var3 >>> 2 * this.shift - 32 & this.indexMask | 1;
  265.       int var8 = 1;
  266.  
  267.       do {
  268.          ++var8;
  269.          var5 = var5 + var6 & this.indexMask;
  270.          var4 = this.hashCodes[var5];
  271.          if (var4 == var2) {
  272.             if (var1.equals(this.keys[var5])) {
  273.                return var5;
  274.             }
  275.          } else {
  276.             if (var4 == 0) {
  277.                if (var7 < 0) {
  278.                   return var5;
  279.                }
  280.  
  281.                return var7;
  282.             }
  283.  
  284.             if (var4 == 1 && var7 == -1) {
  285.                var7 = var5;
  286.             }
  287.          }
  288.       } while(var8 <= this.totalCount);
  289.  
  290.       throw new InconsistencyException("Hashtable overflow");
  291.    }
  292.  
  293.    private void grow(int var1) {
  294.       int var2 = var1 * 4 / 3;
  295.  
  296.       int var3;
  297.       for(var3 = 3; 1 << var3 < var2; ++var3) {
  298.       }
  299.  
  300.       this.shift = 32 - var3 + 1;
  301.       this.grow();
  302.    }
  303.  
  304.    private void grow() {
  305.       --this.shift;
  306.       int var4 = 32 - this.shift;
  307.       this.indexMask = (1 << var4) - 1;
  308.       this.capacity = 3 * (1 << var4) / 4;
  309.       int[] var5 = this.hashCodes;
  310.       Object[] var7 = this.keys;
  311.       Object[] var8 = this.elements;
  312.       this.hashCodes = new int[1 << var4];
  313.       this.keys = new Object[1 << var4];
  314.       this.elements = new Object[1 << var4];
  315.       this.totalCount = 0;
  316.       if (this.count > 0) {
  317.          this.count = 0;
  318.  
  319.          for(int var1 = 0; var1 < var5.length; ++var1) {
  320.             Object var6 = var7[var1];
  321.             if (var6 != null) {
  322.                int var3 = var5[var1];
  323.                int var2 = this.tableIndexFor(var6, var3);
  324.                this.hashCodes[var2] = var3;
  325.                this.keys[var2] = var6;
  326.                this.elements[var2] = var8[var1];
  327.                ++this.count;
  328.                ++this.totalCount;
  329.             }
  330.          }
  331.       }
  332.  
  333.    }
  334.  
  335.    public void clear() {
  336.       if (this.hashCodes != null) {
  337.          for(int var1 = 0; var1 < this.hashCodes.length; ++var1) {
  338.             this.hashCodes[var1] = 0;
  339.             this.keys[var1] = null;
  340.             this.elements[var1] = null;
  341.          }
  342.  
  343.          this.count = 0;
  344.          this.totalCount = 0;
  345.       }
  346.    }
  347.  
  348.    public String toString() {
  349.       return FormattingSerializer.serializeObject(this);
  350.    }
  351.  
  352.    public void describeClassInfo(ClassInfo var1) {
  353.       var1.addClass("netscape.util.Hashtable", 1);
  354.       var1.addField("keys", (byte)19);
  355.       var1.addField("elements", (byte)19);
  356.    }
  357.  
  358.    public void encode(Encoder var1) throws CodingException {
  359.       if (this.count != 0) {
  360.          Object[] var2 = this.keysArray();
  361.          Object[] var3 = this.elementsArray();
  362.          var1.encodeObjectArray("keys", var2, 0, var2.length);
  363.          var1.encodeObjectArray("elements", var3, 0, var3.length);
  364.       }
  365.    }
  366.  
  367.    public void decode(Decoder var1) throws CodingException {
  368.       Object[] var3 = var1.decodeObjectArray("keys");
  369.       Object[] var4 = var1.decodeObjectArray("elements");
  370.       if (var3 != null && var3.length != 0) {
  371.          this.grow(var3.length);
  372.  
  373.          for(int var2 = 0; var2 < var3.length; ++var2) {
  374.             this.put(var3[var2], var4[var2]);
  375.          }
  376.  
  377.       }
  378.    }
  379.  
  380.    public void finishDecoding() throws CodingException {
  381.    }
  382. }
  383.