home *** CD-ROM | disk | FTP | other *** search
/ Symantec Visual Cafe for Java 2.5 / symantec-visual-cafe-2.5-database-dev-edition.iso / Extras / OSpace / jgl.exe / jgl_2_0 / COM / objectspace / jgl / HashMap.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-03-12  |  9.1 KB  |  619 lines
  1. package COM.objectspace.jgl;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.util.Enumeration;
  7.  
  8. public class HashMap extends Map {
  9.    static final int DEFAULT_SIZE = 203;
  10.    static final float DEFAULT_RATIO = 0.75F;
  11.    BinaryPredicate comparator;
  12.    boolean allowDups;
  13.    boolean expandActive;
  14.    transient int size;
  15.    transient HashMapNode[] buckets;
  16.    int length;
  17.    int limit;
  18.    float ratio;
  19.  
  20.    public HashMap() {
  21.       this(new EqualTo(), false, 203, 0.75F);
  22.    }
  23.  
  24.    public HashMap(boolean var1) {
  25.       this(new EqualTo(), var1, 203, 0.75F);
  26.    }
  27.  
  28.    public HashMap(BinaryPredicate var1) {
  29.       this(var1, false, 203, 0.75F);
  30.    }
  31.  
  32.    public HashMap(BinaryPredicate var1, boolean var2) {
  33.       this(var1, var2, 203, 0.75F);
  34.    }
  35.  
  36.    public HashMap(BinaryPredicate var1, int var2, float var3) {
  37.       this(var1, false, var2, var3);
  38.    }
  39.  
  40.    public HashMap(BinaryPredicate var1, boolean var2, int var3, float var4) {
  41.       this.expandActive = true;
  42.       this.comparator = var1;
  43.       this.ratio = var4;
  44.       this.length = var3;
  45.       this.limit = (int)((float)this.length * this.ratio);
  46.       this.buckets = new HashMapNode[this.length];
  47.       this.allowDups = var2;
  48.    }
  49.  
  50.    public HashMap(HashMap var1) {
  51.       this.expandActive = true;
  52.       this.copy(var1);
  53.    }
  54.  
  55.    public boolean allowsDuplicates() {
  56.       return this.allowDups;
  57.    }
  58.  
  59.    public BinaryPredicate getComparator() {
  60.       return this.comparator;
  61.    }
  62.  
  63.    public float getLoadRatio() {
  64.       return this.ratio;
  65.    }
  66.  
  67.    public synchronized Object clone() {
  68.       return new HashMap(this);
  69.    }
  70.  
  71.    public synchronized void copy(HashMap var1) {
  72.       synchronized(var1){}
  73.  
  74.       try {
  75.          this.comparator = var1.comparator;
  76.          this.length = var1.length;
  77.          this.ratio = var1.ratio;
  78.          this.limit = var1.limit;
  79.          this.size = var1.size();
  80.          this.buckets = new HashMapNode[this.length];
  81.          this.allowDups = var1.allowDups;
  82.  
  83.          for(int var4 = 0; var4 < this.length; ++var4) {
  84.             HashMapNode var5 = null;
  85.  
  86.             for(HashMapNode var6 = var1.buckets[var4]; var6 != null; var6 = var6.next) {
  87.                HashMapNode var7 = new HashMapNode(this);
  88.                var7.key = var6.key;
  89.                var7.value = var6.value;
  90.                var7.hash = var6.hash;
  91.                if (this.buckets[var4] == null) {
  92.                   this.buckets[var4] = var7;
  93.                } else {
  94.                   var5.next = var7;
  95.                }
  96.  
  97.                var5 = var7;
  98.             }
  99.          }
  100.       } catch (Throwable var9) {
  101.          throw var9;
  102.       }
  103.  
  104.    }
  105.  
  106.    public synchronized String toString() {
  107.       return "HashMap" + Printing.toString(this.start(), this.finish());
  108.    }
  109.  
  110.    public synchronized Enumeration elements() {
  111.       return new HashMapIterator(this.first(), this, 3);
  112.    }
  113.  
  114.    public ForwardIterator start() {
  115.       return this.begin();
  116.    }
  117.  
  118.    public ForwardIterator finish() {
  119.       return this.end();
  120.    }
  121.  
  122.    public synchronized HashMapIterator begin() {
  123.       return new HashMapIterator(this.first(), this, 1);
  124.    }
  125.  
  126.    public synchronized HashMapIterator end() {
  127.       return new HashMapIterator((HashMapNode)null, this, 1);
  128.    }
  129.  
  130.    public boolean isEmpty() {
  131.       return this.size == 0;
  132.    }
  133.  
  134.    public int size() {
  135.       return this.size;
  136.    }
  137.  
  138.    public int maxSize() {
  139.       return Integer.MAX_VALUE;
  140.    }
  141.  
  142.    public boolean equals(Object var1) {
  143.       return var1 instanceof HashMap && this.equals((HashMap)var1);
  144.    }
  145.  
  146.    public synchronized boolean equals(HashMap var1) {
  147.       synchronized(var1){}
  148.  
  149.       try {
  150.          if (this.size() != var1.size()) {
  151.             boolean var11 = false;
  152.             return var11;
  153.          } else if (!this.allowDups) {
  154.             HashMapIterator var12 = this.begin();
  155.  
  156.             while(var12.myNode != null) {
  157.                Object var13 = var1.get(var12.myNode.key);
  158.                if (var13 == null || !var13.equals(var12.myNode.value)) {
  159.                   boolean var10 = false;
  160.                   return var10;
  161.                }
  162.  
  163.                var12.advance();
  164.             }
  165.  
  166.             return true;
  167.          } else {
  168.             Object var5 = null;
  169.  
  170.             for(HashMapIterator var6 = this.begin(); var6.myNode != null; var6.advance()) {
  171.                Object var7 = var6.myNode.key;
  172.                if (var5 == null || !var7.equals(var5)) {
  173.                   var5 = var7;
  174.                   if (!this.same(this.values(var7), var1.values(var7))) {
  175.                      boolean var2 = false;
  176.                      return var2;
  177.                   }
  178.                }
  179.             }
  180.  
  181.             return true;
  182.          }
  183.       } catch (Throwable var9) {
  184.          throw var9;
  185.       }
  186.    }
  187.  
  188.    public synchronized int hashCode() {
  189.       HashMapIterator var1 = new HashMapIterator(this.first(), this, 2);
  190.       HashMapIterator var2 = new HashMapIterator((HashMapNode)null, this, 2);
  191.       return Hashing.unorderedHash(var1, var2);
  192.    }
  193.  
  194.    public synchronized void swap(HashMap var1) {
  195.       synchronized(var1){}
  196.  
  197.       try {
  198.          int var4 = this.size;
  199.          this.size = var1.size();
  200.          var1.size = var4;
  201.          HashMapNode[] var5 = this.buckets;
  202.          this.buckets = var1.buckets;
  203.          var1.buckets = var5;
  204.          int var6 = this.length;
  205.          this.length = var1.length;
  206.          var1.length = var6;
  207.          int var7 = this.limit;
  208.          this.limit = var1.limit;
  209.          var1.limit = var7;
  210.          float var8 = this.ratio;
  211.          this.ratio = var1.ratio;
  212.          var1.ratio = var8;
  213.          boolean var9 = this.allowDups;
  214.          this.allowDups = var1.allowDups;
  215.          var1.allowDups = var9;
  216.       } catch (Throwable var11) {
  217.          throw var11;
  218.       }
  219.  
  220.    }
  221.  
  222.    public synchronized void clear() {
  223.       this.buckets = new HashMapNode[this.length];
  224.       this.size = 0;
  225.    }
  226.  
  227.    public Object remove(Object var1) {
  228.       return this.removeAux(var1, this.size).first;
  229.    }
  230.  
  231.    public int remove(Object var1, int var2) {
  232.       Pair var3 = this.removeAux(var1, var2);
  233.       return ((Number)var3.second).intValue();
  234.    }
  235.  
  236.    synchronized Pair removeAux(Object var1, int var2) {
  237.       if (var2 > 0) {
  238.          int var3 = var1.hashCode() & Integer.MAX_VALUE;
  239.          int var4 = var3 % this.length;
  240.          HashMapNode var5 = this.buckets[var4];
  241.  
  242.          for(HashMapNode var6 = null; var5 != null; var5 = var5.next) {
  243.             if (var5.hash == var3 && this.comparator.execute(var5.key, var1)) {
  244.                int var7 = 1;
  245.                --var2;
  246.                HashMapNode var8 = var5.next;
  247.                Object var9 = var5.value;
  248.                if (this.allowDups) {
  249.                   while(var2 > 0 && var8 != null && var8.hash == var3 && this.comparator.execute(var8.key, var1)) {
  250.                      ++var7;
  251.                      --var2;
  252.                      var8 = var8.next;
  253.                   }
  254.                }
  255.  
  256.                if (var6 == null) {
  257.                   this.buckets[var4] = var8;
  258.                } else {
  259.                   var6.next = var8;
  260.                }
  261.  
  262.                this.size -= var7;
  263.                return new Pair(var9, new Integer(var7));
  264.             }
  265.  
  266.             var6 = var5;
  267.          }
  268.       }
  269.  
  270.       return new Pair((Object)null, new Integer(0));
  271.    }
  272.  
  273.    public synchronized Object remove(Enumeration var1) {
  274.       if (!(var1 instanceof HashMapIterator)) {
  275.          throw new IllegalArgumentException("Enumeration not a HashMapIterator");
  276.       } else if (((HashMapIterator)var1).myHashMap != this) {
  277.          throw new IllegalArgumentException("Enumeration not for this HashMap");
  278.       } else {
  279.          HashMapNode var2 = ((HashMapIterator)var1).myNode;
  280.          int var3 = var2.hash % this.length;
  281.          HashMapNode var4 = this.buckets[var3];
  282.          if (var2 == var4) {
  283.             this.buckets[var3] = var2.next;
  284.          } else {
  285.             while(var4.next != var2) {
  286.                var4 = var4.next;
  287.             }
  288.  
  289.             var4.next = var2.next;
  290.          }
  291.  
  292.          --this.size;
  293.          return var2 == null ? null : var2.value;
  294.       }
  295.    }
  296.  
  297.    public synchronized int remove(Enumeration var1, Enumeration var2) {
  298.       if (var1 instanceof HashMapIterator && var2 instanceof HashMapIterator) {
  299.          if (((HashMapIterator)var1).myHashMap == this && ((HashMapIterator)var2).myHashMap == this) {
  300.             HashMapIterator var3 = (HashMapIterator)var1;
  301.             HashMapIterator var4 = (HashMapIterator)var2;
  302.  
  303.             int var5;
  304.             for(var5 = 0; var3.myNode != var4.myNode; ++var5) {
  305.                HashMapIterator var6 = new HashMapIterator(var3);
  306.                var6.advance();
  307.                this.remove((Enumeration)var3);
  308.                var3 = var6;
  309.             }
  310.  
  311.             return var5;
  312.          } else {
  313.             throw new IllegalArgumentException("Enumeration not for this HashMap");
  314.          }
  315.       } else {
  316.          throw new IllegalArgumentException("Enumeration not a HashMapIterator");
  317.       }
  318.    }
  319.  
  320.    public synchronized HashMapIterator find(Object var1) {
  321.       int var2 = var1.hashCode() & Integer.MAX_VALUE;
  322.  
  323.       for(HashMapNode var3 = this.buckets[var2 % this.length]; var3 != null; var3 = var3.next) {
  324.          if (var2 == var3.hash && this.comparator.execute(var3.key, var1)) {
  325.             return new HashMapIterator(var3, this, 1);
  326.          }
  327.       }
  328.  
  329.       return new HashMapIterator((HashMapNode)null, this, 1);
  330.    }
  331.  
  332.    public synchronized int count(Object var1) {
  333.       int var2 = var1.hashCode() & Integer.MAX_VALUE;
  334.  
  335.       for(HashMapNode var3 = this.buckets[var2 % this.length]; var3 != null; var3 = var3.next) {
  336.          if (var2 == var3.hash && this.comparator.execute(var3.key, var1)) {
  337.             if (!this.allowDups) {
  338.                return 1;
  339.             }
  340.  
  341.             int var4 = 1;
  342.  
  343.             for(HashMapNode var5 = var3.next; var5 != null && var2 == var5.hash && this.comparator.execute(var5.key, var1); var5 = var5.next) {
  344.                ++var4;
  345.             }
  346.  
  347.             return var4;
  348.          }
  349.       }
  350.  
  351.       return 0;
  352.    }
  353.  
  354.    public synchronized int countValues(Object var1) {
  355.       return Counting.count(new HashMapIterator(this.first(), this, 3), new HashMapIterator((HashMapNode)null, this, 3), var1);
  356.    }
  357.  
  358.    public synchronized Object get(Object var1) {
  359.       int var2 = var1.hashCode() & Integer.MAX_VALUE;
  360.  
  361.       for(HashMapNode var3 = this.buckets[var2 % this.length]; var3 != null; var3 = var3.next) {
  362.          if (var2 == var3.hash && this.comparator.execute(var3.key, var1)) {
  363.             return var3.value;
  364.          }
  365.       }
  366.  
  367.       return null;
  368.    }
  369.  
  370.    public synchronized Object put(Object var1, Object var2) {
  371.       if (var1 != null && var2 != null) {
  372.          int var3 = var1.hashCode() & Integer.MAX_VALUE;
  373.          int var4 = var3 % this.length;
  374.  
  375.          for(HashMapNode var5 = this.buckets[var4]; var5 != null; var5 = var5.next) {
  376.             if (var3 == var5.hash && this.comparator.execute(var5.key, var1)) {
  377.                var5.key = var1;
  378.                Object var6 = var5.value;
  379.                var5.value = var2;
  380.                return var6;
  381.             }
  382.          }
  383.  
  384.          HashMapNode var7 = new HashMapNode(this);
  385.          var7.key = var1;
  386.          var7.value = var2;
  387.          var7.hash = var3;
  388.          var7.next = this.buckets[var4];
  389.          this.buckets[var4] = var7;
  390.          if (++this.size > this.limit) {
  391.             this.expand();
  392.          }
  393.  
  394.          return null;
  395.       } else {
  396.          throw new NullPointerException();
  397.       }
  398.    }
  399.  
  400.    public Object add(Object var1) {
  401.       if (var1 == null) {
  402.          throw new NullPointerException();
  403.       } else if (!(var1 instanceof Pair)) {
  404.          throw new IllegalArgumentException("object is not pair");
  405.       } else if (((Pair)var1).first != null && ((Pair)var1).second != null) {
  406.          Pair var2 = (Pair)var1;
  407.          return this.add(var2.first, var2.second);
  408.       } else {
  409.          throw new NullPointerException();
  410.       }
  411.    }
  412.  
  413.    public synchronized Object add(Object var1, Object var2) {
  414.       if (var1 != null && var2 != null) {
  415.          int var3 = var1.hashCode() & Integer.MAX_VALUE;
  416.          int var4 = var3 % this.length;
  417.  
  418.          for(HashMapNode var5 = this.buckets[var4]; var5 != null; var5 = var5.next) {
  419.             if (var3 == var5.hash && this.comparator.execute(var5.key, var1)) {
  420.                if (this.allowDups) {
  421.                   HashMapNode var6 = new HashMapNode(this);
  422.                   var6.key = var1;
  423.                   var6.value = var2;
  424.                   var6.hash = var3;
  425.                   var6.next = var5.next;
  426.                   var5.next = var6;
  427.                   if (++this.size > this.limit) {
  428.                      this.expand();
  429.                   }
  430.  
  431.                   return null;
  432.                }
  433.  
  434.                return var5.value;
  435.             }
  436.          }
  437.  
  438.          HashMapNode var7 = new HashMapNode(this);
  439.          var7.key = var1;
  440.          var7.value = var2;
  441.          var7.hash = var3;
  442.          var7.next = this.buckets[var4];
  443.          this.buckets[var4] = var7;
  444.          if (++this.size > this.limit) {
  445.             this.expand();
  446.          }
  447.  
  448.          return null;
  449.       } else {
  450.          throw new NullPointerException();
  451.       }
  452.    }
  453.  
  454.    public synchronized Enumeration keys() {
  455.       return new HashMapIterator(this.first(), this, 2);
  456.    }
  457.  
  458.    public synchronized Enumeration keys(Object var1) {
  459.       Array var2 = new Array();
  460.  
  461.       for(HashMapIterator var3 = this.begin(); var3.myNode != null; var3.advance()) {
  462.          if (var3.myNode.value.equals(var1)) {
  463.             var2.pushBack(var3.myNode.key);
  464.          }
  465.       }
  466.  
  467.       return var2.elements();
  468.    }
  469.  
  470.    public synchronized Enumeration values(Object var1) {
  471.       Array var2 = new Array();
  472.  
  473.       for(HashMapIterator var3 = this.begin(); var3.myNode != null; var3.advance()) {
  474.          if (this.comparator.execute(var3.myNode.key, var1)) {
  475.             var2.pushBack(var3.myNode.value);
  476.          }
  477.       }
  478.  
  479.       return var2.elements();
  480.    }
  481.  
  482.    public synchronized HashMapIterator lowerBound(Object var1) {
  483.       return (HashMapIterator)this.equalRange(var1).begin;
  484.    }
  485.  
  486.    public synchronized HashMapIterator upperBound(Object var1) {
  487.       return (HashMapIterator)this.equalRange(var1).end;
  488.    }
  489.  
  490.    public synchronized Range equalRange(Object var1) {
  491.       int var2 = var1.hashCode() & Integer.MAX_VALUE;
  492.  
  493.       for(HashMapNode var3 = this.buckets[var2 % this.length]; var3 != null; var3 = var3.next) {
  494.          if (var2 == var3.hash && this.comparator.execute(var3.key, var1)) {
  495.             HashMapNode var4 = var3;
  496.  
  497.             for(var3 = var3.next == null ? this.next(var3) : var3.next; var3 != null && var2 == var3.hash && this.comparator.execute(var3.key, var1); var3 = var3.next == null ? this.next(var3) : var3.next) {
  498.             }
  499.  
  500.             return new Range(new HashMapIterator(var4, this, 1), new HashMapIterator(var3, this, 1));
  501.          }
  502.       }
  503.  
  504.       return new Range(this.end(), this.end());
  505.    }
  506.  
  507.    private HashMapNode first() {
  508.       if (this.size > 0) {
  509.          for(int var1 = 0; var1 < this.length; ++var1) {
  510.             if (this.buckets[var1] != null) {
  511.                return this.buckets[var1];
  512.             }
  513.          }
  514.       }
  515.  
  516.       return null;
  517.    }
  518.  
  519.    private HashMapNode next(HashMapNode var1) {
  520.       for(int var2 = var1.hash % this.length + 1; var2 < this.length; ++var2) {
  521.          if (this.buckets[var2] != null) {
  522.             return this.buckets[var2];
  523.          }
  524.       }
  525.  
  526.       return null;
  527.    }
  528.  
  529.    public boolean expansionAllowed() {
  530.       return this.expandActive;
  531.    }
  532.  
  533.    public synchronized void allowExpansion(boolean var1) {
  534.       this.expandActive = var1;
  535.    }
  536.  
  537.    private void expand() {
  538.       if (this.expansionAllowed()) {
  539.          int var1 = this.length * 2 + 1;
  540.          HashMapNode[] var2 = new HashMapNode[var1];
  541.  
  542.          HashMapNode var5;
  543.          int var6;
  544.          for(int var3 = 0; var3 < this.length; ++var3) {
  545.             for(HashMapNode var4 = this.buckets[var3]; var4 != null; var2[var6] = var5) {
  546.                var5 = var4;
  547.                var4 = var4.next;
  548.                var6 = var5.hash % var1;
  549.                var5.next = var2[var6];
  550.             }
  551.          }
  552.  
  553.          this.buckets = var2;
  554.          this.length = var1;
  555.          this.limit = (int)((float)this.length * this.ratio);
  556.       }
  557.    }
  558.  
  559.    private boolean same(Enumeration var1, Enumeration var2) {
  560.       Array var3 = new Array();
  561.       Array var4 = new Array();
  562.  
  563.       while(var1.hasMoreElements()) {
  564.          var3.add(var1.nextElement());
  565.       }
  566.  
  567.       while(var2.hasMoreElements()) {
  568.          var4.add(var2.nextElement());
  569.       }
  570.  
  571.       if (var3.size() != var4.size()) {
  572.          return false;
  573.       } else {
  574.          for(int var5 = 0; var5 < var3.size(); ++var5) {
  575.             Object var6 = var3.at(var5);
  576.             int var7 = 0;
  577.             int var8 = 0;
  578.  
  579.             for(int var9 = 0; var9 < var4.size(); ++var9) {
  580.                if (var3.at(var9).equals(var6)) {
  581.                   ++var7;
  582.                }
  583.  
  584.                if (var4.at(var9).equals(var6)) {
  585.                   ++var8;
  586.                }
  587.             }
  588.  
  589.             if (var7 != var8) {
  590.                return false;
  591.             }
  592.          }
  593.  
  594.          return true;
  595.       }
  596.    }
  597.  
  598.    private void size(int var1) {
  599.       this.size = var1;
  600.    }
  601.  
  602.    private synchronized void writeObject(ObjectOutputStream var1) throws IOException {
  603.       var1.defaultWriteObject();
  604.       var1.writeInt(this.size);
  605.       Copying.copy(this.begin(), this.end(), new ObjectOutputStreamIterator(var1));
  606.    }
  607.  
  608.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  609.       var1.defaultReadObject();
  610.       this.buckets = new HashMapNode[this.length];
  611.       int var2 = var1.readInt();
  612.  
  613.       while(var2-- > 0) {
  614.          this.add(var1.readObject());
  615.       }
  616.  
  617.    }
  618. }
  619.