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 / HashSet.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-03-12  |  9.2 KB  |  688 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 HashSet implements Set {
  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 HashSetNode[] buckets;
  16.    int length;
  17.    int limit;
  18.    float ratio;
  19.  
  20.    public HashSet() {
  21.       this(new EqualTo(), false, 203, 0.75F);
  22.    }
  23.  
  24.    public HashSet(boolean var1) {
  25.       this(new EqualTo(), var1, 203, 0.75F);
  26.    }
  27.  
  28.    public HashSet(BinaryPredicate var1) {
  29.       this(var1, false, 203, 0.75F);
  30.    }
  31.  
  32.    public HashSet(BinaryPredicate var1, boolean var2) {
  33.       this(var1, var2, 203, 0.75F);
  34.    }
  35.  
  36.    public HashSet(BinaryPredicate var1, int var2, float var3) {
  37.       this(var1, false, var2, var3);
  38.    }
  39.  
  40.    public HashSet(BinaryPredicate var1, boolean var2, int var3, float var4) {
  41.       this.allowDups = false;
  42.       this.expandActive = true;
  43.       this.comparator = var1;
  44.       this.allowDups = var2;
  45.       this.ratio = var4;
  46.       this.length = var3;
  47.       this.limit = (int)((float)this.length * this.ratio);
  48.       this.buckets = new HashSetNode[this.length];
  49.    }
  50.  
  51.    public HashSet(HashSet var1) {
  52.       this.allowDups = false;
  53.       this.expandActive = true;
  54.       this.copy(var1);
  55.    }
  56.  
  57.    public boolean allowsDuplicates() {
  58.       return this.allowDups;
  59.    }
  60.  
  61.    public BinaryPredicate getComparator() {
  62.       return this.comparator;
  63.    }
  64.  
  65.    public float getLoadRatio() {
  66.       return this.ratio;
  67.    }
  68.  
  69.    public synchronized Object clone() {
  70.       return new HashSet(this);
  71.    }
  72.  
  73.    public synchronized void copy(HashSet var1) {
  74.       synchronized(var1){}
  75.  
  76.       try {
  77.          this.comparator = var1.comparator;
  78.          this.length = var1.length;
  79.          this.ratio = var1.ratio;
  80.          this.limit = var1.limit;
  81.          this.size = var1.size;
  82.          this.buckets = new HashSetNode[this.length];
  83.          this.allowDups = var1.allowDups;
  84.  
  85.          for(int var4 = 0; var4 < this.length; ++var4) {
  86.             HashSetNode var5 = null;
  87.  
  88.             for(HashSetNode var6 = var1.buckets[var4]; var6 != null; var6 = var6.next) {
  89.                HashSetNode var7 = new HashSetNode(this);
  90.                var7.object = var6.object;
  91.                var7.hash = var6.hash;
  92.                if (this.buckets[var4] == null) {
  93.                   this.buckets[var4] = var7;
  94.                } else {
  95.                   var5.next = var7;
  96.                }
  97.  
  98.                var5 = var7;
  99.             }
  100.          }
  101.       } catch (Throwable var9) {
  102.          throw var9;
  103.       }
  104.  
  105.    }
  106.  
  107.    public synchronized String toString() {
  108.       return "HashSet" + Printing.toString(this.start(), this.finish());
  109.    }
  110.  
  111.    public synchronized Enumeration elements() {
  112.       return new HashSetIterator(this.first(), this);
  113.    }
  114.  
  115.    public ForwardIterator start() {
  116.       return this.begin();
  117.    }
  118.  
  119.    public ForwardIterator finish() {
  120.       return this.end();
  121.    }
  122.  
  123.    public synchronized HashSetIterator begin() {
  124.       return new HashSetIterator(this.first(), this);
  125.    }
  126.  
  127.    public synchronized HashSetIterator end() {
  128.       return new HashSetIterator((HashSetNode)null, this);
  129.    }
  130.  
  131.    public boolean isEmpty() {
  132.       return this.size == 0;
  133.    }
  134.  
  135.    public int size() {
  136.       return this.size;
  137.    }
  138.  
  139.    public int maxSize() {
  140.       return Integer.MAX_VALUE;
  141.    }
  142.  
  143.    public boolean equals(Object var1) {
  144.       return var1 instanceof HashSet && this.equals((HashSet)var1);
  145.    }
  146.  
  147.    public synchronized boolean equals(HashSet var1) {
  148.       synchronized(var1){}
  149.  
  150.       try {
  151.          if (this.size != var1.size) {
  152.             boolean var11 = false;
  153.             return var11;
  154.          } else if (!this.allowDups) {
  155.             HashSetIterator var12 = this.begin();
  156.  
  157.             while(var12.myNode != null) {
  158.                if (var1.count(var12.myNode.object) == 0) {
  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(HashSetIterator var6 = this.begin(); var6.myNode != null; var6.advance()) {
  171.                Object var7 = var6.myNode.object;
  172.                if (var5 == null || !var7.equals(var5)) {
  173.                   if (this.count(var7) != var1.count(var7)) {
  174.                      boolean var2 = false;
  175.                      return var2;
  176.                   }
  177.  
  178.                   var5 = var7;
  179.                }
  180.             }
  181.  
  182.             return true;
  183.          }
  184.       } catch (Throwable var9) {
  185.          throw var9;
  186.       }
  187.    }
  188.  
  189.    public synchronized int hashCode() {
  190.       return Hashing.unorderedHash(this.start(), this.finish());
  191.    }
  192.  
  193.    public synchronized void swap(HashSet var1) {
  194.       synchronized(var1){}
  195.  
  196.       try {
  197.          int var4 = this.size;
  198.          this.size = var1.size;
  199.          var1.size = var4;
  200.          HashSetNode[] var5 = this.buckets;
  201.          this.buckets = var1.buckets;
  202.          var1.buckets = var5;
  203.          int var6 = this.length;
  204.          this.length = var1.length;
  205.          var1.length = var6;
  206.          int var7 = this.limit;
  207.          this.limit = var1.limit;
  208.          var1.limit = var7;
  209.          float var8 = this.ratio;
  210.          this.ratio = var1.ratio;
  211.          var1.ratio = var8;
  212.          boolean var9 = this.allowDups;
  213.          this.allowDups = var1.allowDups;
  214.          var1.allowDups = var9;
  215.       } catch (Throwable var11) {
  216.          throw var11;
  217.       }
  218.  
  219.    }
  220.  
  221.    public synchronized void clear() {
  222.       this.buckets = new HashSetNode[this.length];
  223.       this.size = 0;
  224.    }
  225.  
  226.    public int remove(Object var1) {
  227.       Pair var2 = this.removeAux(var1, this.size);
  228.       return ((Number)var2.second).intValue();
  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.          HashSetNode var5 = this.buckets[var4];
  241.  
  242.          for(HashSetNode var6 = null; var5 != null; var5 = var5.next) {
  243.             if (var5.hash == var3 && this.comparator.execute(var5.object, var1)) {
  244.                int var7 = 1;
  245.                --var2;
  246.                HashSetNode var8 = var5.next;
  247.                Object var9 = var5.object;
  248.                if (this.allowDups) {
  249.                   while(var2 > 0 && var8 != null && var8.hash == var3 && this.comparator.execute(var8.object, 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 HashSetIterator)) {
  275.          throw new IllegalArgumentException("Enumeration not a HashSetIterator");
  276.       } else if (((HashSetIterator)var1).myHashSet != this) {
  277.          throw new IllegalArgumentException("Enumeration not for this HashSet");
  278.       } else {
  279.          HashSetIterator var2 = (HashSetIterator)var1;
  280.          HashSetNode var3 = var2.myNode;
  281.          int var4 = var3.hash % this.length;
  282.          HashSetNode var5 = this.buckets[var4];
  283.          if (var3 == var5) {
  284.             this.buckets[var4] = var3.next;
  285.          } else {
  286.             while(var5.next != var3) {
  287.                var5 = var5.next;
  288.             }
  289.  
  290.             var5.next = var3.next;
  291.          }
  292.  
  293.          --this.size;
  294.          return var3 == null ? null : var3.object;
  295.       }
  296.    }
  297.  
  298.    public synchronized int remove(Enumeration var1, Enumeration var2) {
  299.       if (var1 instanceof HashSetIterator && var2 instanceof HashSetIterator) {
  300.          if (((HashSetIterator)var1).myHashSet == this && ((HashSetIterator)var2).myHashSet == this) {
  301.             HashSetIterator var3 = (HashSetIterator)var1;
  302.             HashSetIterator var4 = (HashSetIterator)var2;
  303.  
  304.             int var5;
  305.             for(var5 = 0; var3.myNode != var4.myNode; ++var5) {
  306.                HashSetIterator var6 = new HashSetIterator(var3);
  307.                var6.advance();
  308.                this.remove((Enumeration)var3);
  309.                var3 = var6;
  310.             }
  311.  
  312.             return var5;
  313.          } else {
  314.             throw new IllegalArgumentException("Enumeration not for this HashSet");
  315.          }
  316.       } else {
  317.          throw new IllegalArgumentException("Enumeration not a HashSetIterator");
  318.       }
  319.    }
  320.  
  321.    public synchronized HashSetIterator find(Object var1) {
  322.       int var2 = var1.hashCode() & Integer.MAX_VALUE;
  323.  
  324.       for(HashSetNode var3 = this.buckets[var2 % this.length]; var3 != null; var3 = var3.next) {
  325.          if (var2 == var3.hash && this.comparator.execute(var3.object, var1)) {
  326.             return new HashSetIterator(var3, this);
  327.          }
  328.       }
  329.  
  330.       return new HashSetIterator((HashSetNode)null, this);
  331.    }
  332.  
  333.    public synchronized int count(Object var1) {
  334.       int var2 = var1.hashCode() & Integer.MAX_VALUE;
  335.  
  336.       for(HashSetNode var3 = this.buckets[var2 % this.length]; var3 != null; var3 = var3.next) {
  337.          if (var2 == var3.hash && this.comparator.execute(var3.object, var1)) {
  338.             if (!this.allowDups) {
  339.                return 1;
  340.             }
  341.  
  342.             int var4 = 1;
  343.  
  344.             for(HashSetNode var5 = var3.next; var5 != null && var2 == var5.hash && this.comparator.execute(var5.object, var1); var5 = var5.next) {
  345.                ++var4;
  346.             }
  347.  
  348.             return var4;
  349.          }
  350.       }
  351.  
  352.       return 0;
  353.    }
  354.  
  355.    public synchronized Object add(Object var1) {
  356.       if (var1 == null) {
  357.          throw new NullPointerException();
  358.       } else {
  359.          int var2 = var1.hashCode() & Integer.MAX_VALUE;
  360.          int var3 = var2 % this.length;
  361.  
  362.          for(HashSetNode var4 = this.buckets[var3]; var4 != null; var4 = var4.next) {
  363.             if (var2 == var4.hash && this.comparator.execute(var4.object, var1)) {
  364.                if (this.allowDups) {
  365.                   HashSetNode var5 = new HashSetNode(this);
  366.                   var5.object = var1;
  367.                   var5.hash = var2;
  368.                   var5.next = var4.next;
  369.                   var4.next = var5;
  370.                   if (++this.size > this.limit) {
  371.                      this.expand();
  372.                   }
  373.  
  374.                   return null;
  375.                }
  376.  
  377.                return var4.object;
  378.             }
  379.          }
  380.  
  381.          HashSetNode var6 = new HashSetNode(this);
  382.          var6.object = var1;
  383.          var6.hash = var2;
  384.          var6.next = this.buckets[var3];
  385.          this.buckets[var3] = var6;
  386.          if (++this.size > this.limit) {
  387.             this.expand();
  388.          }
  389.  
  390.          return null;
  391.       }
  392.    }
  393.  
  394.    public synchronized Object get(Object var1) {
  395.       int var2 = var1.hashCode() & Integer.MAX_VALUE;
  396.  
  397.       for(HashSetNode var3 = this.buckets[var2 % this.length]; var3 != null; var3 = var3.next) {
  398.          if (var2 == var3.hash && this.comparator.execute(var3.object, var1)) {
  399.             return var3.object;
  400.          }
  401.       }
  402.  
  403.       return null;
  404.    }
  405.  
  406.    public synchronized Object put(Object var1) {
  407.       if (var1 == null) {
  408.          throw new NullPointerException();
  409.       } else {
  410.          int var2 = var1.hashCode() & Integer.MAX_VALUE;
  411.          int var3 = var2 % this.length;
  412.  
  413.          for(HashSetNode var4 = this.buckets[var3]; var4 != null; var4 = var4.next) {
  414.             if (var2 == var4.hash && this.comparator.execute(var4.object, var1)) {
  415.                Object var5 = var4.object;
  416.                var4.object = var1;
  417.                return var5;
  418.             }
  419.          }
  420.  
  421.          HashSetNode var6 = new HashSetNode(this);
  422.          var6.object = var1;
  423.          var6.hash = var2;
  424.          var6.next = this.buckets[var3];
  425.          this.buckets[var3] = var6;
  426.          if (++this.size > this.limit) {
  427.             this.expand();
  428.          }
  429.  
  430.          return null;
  431.       }
  432.    }
  433.  
  434.    public synchronized HashSet union(HashSet var1) {
  435.       synchronized(var1){}
  436.  
  437.       HashSet var2;
  438.       try {
  439.          if (this.allowDups || var1.allowDups) {
  440.             throw new InvalidOperationException("union operation invalid on multisets");
  441.          }
  442.  
  443.          HashSet var5 = new HashSet();
  444.          InsertIterator var6 = new InsertIterator(var5);
  445.          Copying.copy(this.start(), this.finish(), var6);
  446.          Copying.copy(var1.start(), var1.finish(), var6);
  447.          var2 = var5;
  448.       } catch (Throwable var10) {
  449.          throw var10;
  450.       }
  451.  
  452.       return var2;
  453.    }
  454.  
  455.    public synchronized HashSet intersection(HashSet var1) {
  456.       synchronized(var1){}
  457.  
  458.       HashSet var2;
  459.       try {
  460.          if (this.allowDups || var1.allowDups) {
  461.             throw new InvalidOperationException("intersection operation invalid on multisets");
  462.          }
  463.  
  464.          HashSet var5 = new HashSet();
  465.          HashSetIterator var6;
  466.          if (this.size >= var1.size) {
  467.             var6 = this.begin();
  468.          } else {
  469.             var6 = var1.begin();
  470.             var1 = this;
  471.          }
  472.  
  473.          while(var6.myNode != null) {
  474.             Object var7 = var6.nextElement();
  475.             if (var1.count(var7) > 0) {
  476.                var5.add(var7);
  477.             }
  478.          }
  479.  
  480.          var2 = var5;
  481.       } catch (Throwable var9) {
  482.          throw var9;
  483.       }
  484.  
  485.       return var2;
  486.    }
  487.  
  488.    public synchronized HashSet difference(HashSet var1) {
  489.       synchronized(var1){}
  490.  
  491.       HashSet var2;
  492.       try {
  493.          if (this.allowDups || var1.allowDups) {
  494.             throw new InvalidOperationException("difference operation invalid on multisets");
  495.          }
  496.  
  497.          HashSet var5 = new HashSet();
  498.          HashSetIterator var6 = this.begin();
  499.  
  500.          while(var6.myNode != null) {
  501.             Object var7 = var6.nextElement();
  502.             if (var1.count(var7) == 0) {
  503.                var5.add(var7);
  504.             }
  505.          }
  506.  
  507.          var2 = var5;
  508.       } catch (Throwable var9) {
  509.          throw var9;
  510.       }
  511.  
  512.       return var2;
  513.    }
  514.  
  515.    public synchronized HashSet symmetricDifference(HashSet var1) {
  516.       synchronized(var1){}
  517.  
  518.       HashSet var2;
  519.       try {
  520.          if (this.allowDups || var1.allowDups) {
  521.             throw new InvalidOperationException("symmetricDifference operation invalid on multisets");
  522.          }
  523.  
  524.          HashSet var5 = new HashSet();
  525.          HashSetIterator var6 = this.begin();
  526.  
  527.          while(var6.myNode != null) {
  528.             Object var7 = var6.nextElement();
  529.             if (var1.count(var7) == 0) {
  530.                var5.add(var7);
  531.             }
  532.          }
  533.  
  534.          var6 = var1.begin();
  535.  
  536.          while(var6.myNode != null) {
  537.             Object var11 = var6.nextElement();
  538.             if (this.count(var11) == 0) {
  539.                var5.add(var11);
  540.             }
  541.          }
  542.  
  543.          var2 = var5;
  544.       } catch (Throwable var9) {
  545.          throw var9;
  546.       }
  547.  
  548.       return var2;
  549.    }
  550.  
  551.    public synchronized boolean subsetOf(HashSet var1) {
  552.       synchronized(var1){}
  553.  
  554.       boolean var2;
  555.       try {
  556.          if (this.allowDups || var1.allowDups) {
  557.             throw new InvalidOperationException("subsetOf operation invalid on multisets");
  558.          }
  559.  
  560.          HashSetIterator var5 = this.begin();
  561.  
  562.          do {
  563.             if (var5.myNode == null) {
  564.                var2 = true;
  565.                return var2;
  566.             }
  567.          } while(var1.count(var5.nextElement()) != 0);
  568.  
  569.          var2 = false;
  570.       } catch (Throwable var7) {
  571.          throw var7;
  572.       }
  573.  
  574.       return var2;
  575.    }
  576.  
  577.    public synchronized boolean properSubsetOf(HashSet var1) {
  578.       synchronized(var1){}
  579.  
  580.       boolean var2;
  581.       try {
  582.          if (this.allowDups || var1.allowDups) {
  583.             throw new InvalidOperationException("properSubsetOf operation invalid on multisets");
  584.          }
  585.  
  586.          var2 = this.size < var1.size && this.subsetOf(var1);
  587.       } catch (Throwable var6) {
  588.          throw var6;
  589.       }
  590.  
  591.       return var2;
  592.    }
  593.  
  594.    public synchronized HashSetIterator lowerBound(Object var1) {
  595.       return (HashSetIterator)this.equalRange(var1).begin;
  596.    }
  597.  
  598.    public synchronized HashSetIterator upperBound(Object var1) {
  599.       return (HashSetIterator)this.equalRange(var1).end;
  600.    }
  601.  
  602.    public synchronized Range equalRange(Object var1) {
  603.       int var2 = var1.hashCode() & Integer.MAX_VALUE;
  604.  
  605.       for(HashSetNode var3 = this.buckets[var2 % this.length]; var3 != null; var3 = var3.next) {
  606.          if (var2 == var3.hash && this.comparator.execute(var3.object, var1)) {
  607.             HashSetNode var4 = var3;
  608.  
  609.             for(var3 = var3.next; var3 != null && var2 == var3.hash && this.comparator.execute(var3.object, var1); var3 = var3.next == null ? this.next(var3) : var3.next) {
  610.             }
  611.  
  612.             return new Range(new HashSetIterator(var4, this), new HashSetIterator(var3, this));
  613.          }
  614.       }
  615.  
  616.       return new Range(this.end(), this.end());
  617.    }
  618.  
  619.    private HashSetNode first() {
  620.       if (this.size > 0) {
  621.          for(int var1 = 0; var1 < this.length; ++var1) {
  622.             if (this.buckets[var1] != null) {
  623.                return this.buckets[var1];
  624.             }
  625.          }
  626.       }
  627.  
  628.       return null;
  629.    }
  630.  
  631.    private HashSetNode next(HashSetNode var1) {
  632.       for(int var2 = var1.hash % this.length + 1; var2 < this.length; ++var2) {
  633.          if (this.buckets[var2] != null) {
  634.             return this.buckets[var2];
  635.          }
  636.       }
  637.  
  638.       return null;
  639.    }
  640.  
  641.    public boolean expansionAllowed() {
  642.       return this.expandActive;
  643.    }
  644.  
  645.    public synchronized void allowExpansion(boolean var1) {
  646.       this.expandActive = var1;
  647.    }
  648.  
  649.    private void expand() {
  650.       if (this.expansionAllowed()) {
  651.          int var1 = this.length * 2 + 1;
  652.          HashSetNode[] var2 = new HashSetNode[var1];
  653.  
  654.          HashSetNode var5;
  655.          int var6;
  656.          for(int var3 = 0; var3 < this.length; ++var3) {
  657.             for(HashSetNode var4 = this.buckets[var3]; var4 != null; var2[var6] = var5) {
  658.                var5 = var4;
  659.                var4 = var4.next;
  660.                var6 = var5.hash % var1;
  661.                var5.next = var2[var6];
  662.             }
  663.          }
  664.  
  665.          this.buckets = var2;
  666.          this.length = var1;
  667.          this.limit = (int)((float)this.length * this.ratio);
  668.       }
  669.    }
  670.  
  671.    private synchronized void writeObject(ObjectOutputStream var1) throws IOException {
  672.       var1.defaultWriteObject();
  673.       var1.writeInt(this.size);
  674.       Copying.copy(this.begin(), this.end(), new ObjectOutputStreamIterator(var1));
  675.    }
  676.  
  677.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  678.       var1.defaultReadObject();
  679.       this.buckets = new HashSetNode[this.length];
  680.       int var2 = var1.readInt();
  681.  
  682.       while(var2-- > 0) {
  683.          this.add(var1.readObject());
  684.       }
  685.  
  686.    }
  687. }
  688.