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 / Deque.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-03-12  |  10.4 KB  |  645 lines
  1. package COM.objectspace.jgl;
  2.  
  3. import java.util.Enumeration;
  4.  
  5. public class Deque implements Sequence {
  6.    DequeIterator myStart = new DequeIterator(this, 0, 0);
  7.    DequeIterator myFinish = new DequeIterator(this, 0, 0);
  8.    int myLength;
  9.    Object[][] myMap;
  10.    static final int BLOCK_SIZE = Allocator.pageSize() / 8;
  11.  
  12.    public Deque() {
  13.    }
  14.  
  15.    public Deque(int var1) {
  16.       this.insert(this.myStart, var1, (Object)null);
  17.    }
  18.  
  19.    public Deque(int var1, Object var2) {
  20.       this.insert(this.myStart, var1, var2);
  21.    }
  22.  
  23.    public Deque(Deque var1) {
  24.       synchronized(var1){}
  25.  
  26.       try {
  27.          InsertIterator var5 = new InsertIterator(this);
  28.          Copying.copy(var1.start(), var1.finish(), var5);
  29.       } catch (Throwable var7) {
  30.          throw var7;
  31.       }
  32.  
  33.    }
  34.  
  35.    public synchronized Object clone() {
  36.       return new Deque(this);
  37.    }
  38.  
  39.    public boolean equals(Object var1) {
  40.       return var1 instanceof Deque && this.equals((Deque)var1);
  41.    }
  42.  
  43.    public synchronized boolean equals(Deque var1) {
  44.       synchronized(var1){}
  45.  
  46.       boolean var2;
  47.       try {
  48.          var2 = this.size() == var1.size() && Comparing.equal(this.start(), this.finish(), var1.start());
  49.       } catch (Throwable var8) {
  50.          throw var8;
  51.       }
  52.  
  53.       return var2;
  54.    }
  55.  
  56.    public synchronized int hashCode() {
  57.       return Hashing.orderedHash(this.start(), this.finish());
  58.    }
  59.  
  60.    public synchronized String toString() {
  61.       return "Deque" + Printing.toString(this.start(), this.finish());
  62.    }
  63.  
  64.    public synchronized void copy(Deque var1) {
  65.       if (this != var1) {
  66.          synchronized(var1){}
  67.  
  68.          try {
  69.             if (this.myLength >= var1.myLength) {
  70.                DequeIterator var4 = (DequeIterator)Copying.copy(var1.myStart, var1.myFinish, this.myStart);
  71.                this.remove(var4, this.myFinish);
  72.             } else {
  73.                DequeIterator var8 = var1.myStart.copy(this.myLength);
  74.                Copying.copy(var1.myStart, var8, this.myStart);
  75.                DequeIterator var5 = var8;
  76.  
  77.                while(!var5.equals(var5.myDeque.myFinish)) {
  78.                   this.add(var5.myDeque.myMap[var5.myMapIndex][var5.myBlockIndex]);
  79.                   if (++var5.myBlockIndex == BLOCK_SIZE) {
  80.                      ++var5.myMapIndex;
  81.                      var5.myBlockIndex = 0;
  82.                   }
  83.                }
  84.             }
  85.          } catch (Throwable var7) {
  86.             throw var7;
  87.          }
  88.  
  89.       }
  90.    }
  91.  
  92.    public boolean isEmpty() {
  93.       return this.myLength == 0;
  94.    }
  95.  
  96.    public int size() {
  97.       return this.myLength;
  98.    }
  99.  
  100.    public int maxSize() {
  101.       return Integer.MAX_VALUE;
  102.    }
  103.  
  104.    public synchronized Object add(Object var1) {
  105.       if (this.myLength++ == 0) {
  106.          this.createMap();
  107.          this.myMap[this.myFinish.myMapIndex][this.myFinish.myBlockIndex++] = var1;
  108.       } else {
  109.          this.myMap[this.myFinish.myMapIndex][this.myFinish.myBlockIndex++] = var1;
  110.          if (this.myFinish.myBlockIndex == BLOCK_SIZE) {
  111.             if (this.myFinish.myMapIndex == this.myMap.length - 1) {
  112.                this.growMap();
  113.             }
  114.  
  115.             this.myMap[++this.myFinish.myMapIndex] = new Object[BLOCK_SIZE];
  116.             this.myFinish.myBlockIndex = 0;
  117.          }
  118.       }
  119.  
  120.       return null;
  121.    }
  122.  
  123.    public void pushBack(Object var1) {
  124.       this.add(var1);
  125.    }
  126.  
  127.    public synchronized void pushFront(Object var1) {
  128.       if (this.myLength == 0) {
  129.          this.add(var1);
  130.       } else {
  131.          ++this.myLength;
  132.          if (--this.myStart.myBlockIndex < 0) {
  133.             if (this.myStart.myMapIndex == 0) {
  134.                this.growMap();
  135.             }
  136.  
  137.             this.myMap[--this.myStart.myMapIndex] = new Object[BLOCK_SIZE];
  138.             this.myStart.myBlockIndex = BLOCK_SIZE - 1;
  139.          }
  140.  
  141.          this.myMap[this.myStart.myMapIndex][this.myStart.myBlockIndex] = var1;
  142.       }
  143.    }
  144.  
  145.    public synchronized Object popFront() {
  146.       if (this.myLength == 0) {
  147.          throw new InvalidOperationException("Deque is empty");
  148.       } else {
  149.          Object var1 = this.method_0(0);
  150.          if (--this.myLength == 0) {
  151.             this.clear();
  152.          } else {
  153.             var1 = this.myMap[this.myStart.myMapIndex][this.myStart.myBlockIndex];
  154.             this.myMap[this.myStart.myMapIndex][this.myStart.myBlockIndex++] = null;
  155.             if (this.myStart.myBlockIndex == BLOCK_SIZE) {
  156.                this.myMap[this.myStart.myMapIndex++] = null;
  157.                this.myStart.myBlockIndex = 0;
  158.             }
  159.          }
  160.  
  161.          return var1;
  162.       }
  163.    }
  164.  
  165.    public synchronized Object popBack() {
  166.       if (this.myLength == 0) {
  167.          throw new InvalidOperationException("Deque is empty");
  168.       } else {
  169.          Object var1 = this.method_0(0);
  170.          if (--this.myLength == 0) {
  171.             this.clear();
  172.          } else {
  173.             if (this.myFinish.myBlockIndex-- == 0) {
  174.                this.myMap[this.myFinish.myMapIndex--] = null;
  175.                this.myFinish.myBlockIndex = BLOCK_SIZE - 1;
  176.             }
  177.  
  178.             var1 = this.myMap[this.myFinish.myMapIndex][this.myFinish.myBlockIndex];
  179.             this.myMap[this.myFinish.myMapIndex][this.myFinish.myBlockIndex] = null;
  180.          }
  181.  
  182.          return var1;
  183.       }
  184.    }
  185.  
  186.    public synchronized void clear() {
  187.       this.myMap = null;
  188.       this.myStart.myMapIndex = 0;
  189.       this.myStart.myBlockIndex = 0;
  190.       this.myFinish.myMapIndex = 0;
  191.       this.myFinish.myBlockIndex = 0;
  192.       this.myLength = 0;
  193.    }
  194.  
  195.    public synchronized Enumeration elements() {
  196.       return new DequeIterator(this.myStart);
  197.    }
  198.  
  199.    public synchronized DequeIterator begin() {
  200.       return new DequeIterator(this.myStart);
  201.    }
  202.  
  203.    public synchronized DequeIterator end() {
  204.       return new DequeIterator(this.myFinish);
  205.    }
  206.  
  207.    public ForwardIterator start() {
  208.       return this.begin();
  209.    }
  210.  
  211.    public ForwardIterator finish() {
  212.       return this.end();
  213.    }
  214.  
  215.    public synchronized Object front() {
  216.       if (this.myLength == 0) {
  217.          throw new InvalidOperationException("Deque is empty");
  218.       } else {
  219.          return this.myMap[this.myStart.myMapIndex][this.myStart.myBlockIndex];
  220.       }
  221.    }
  222.  
  223.    public synchronized Object back() {
  224.       if (this.myLength == 0) {
  225.          throw new InvalidOperationException("Deque is empty");
  226.       } else {
  227.          return this.myFinish.myBlockIndex > 0 ? this.myMap[this.myFinish.myMapIndex][this.myFinish.myBlockIndex - 1] : this.myMap[this.myFinish.myMapIndex - 1][BLOCK_SIZE - 1];
  228.       }
  229.    }
  230.  
  231.    // $FF: renamed from: at (int) java.lang.Object
  232.    public synchronized Object method_0(int var1) {
  233.       if (var1 >= 0 && var1 < this.myLength) {
  234.          int var2 = this.myStart.myBlockIndex + var1;
  235.          int var3 = this.myStart.myMapIndex;
  236.          if (var2 >= BLOCK_SIZE) {
  237.             int var4 = var2 / BLOCK_SIZE;
  238.             var3 += var4;
  239.             var2 %= BLOCK_SIZE;
  240.          } else if (var2 < 0) {
  241.             int var5 = (BLOCK_SIZE - 1 - var2) / BLOCK_SIZE;
  242.             var3 -= var5;
  243.             var2 += var5 * BLOCK_SIZE;
  244.          }
  245.  
  246.          return this.myMap[var3][var2];
  247.       } else {
  248.          throw new IndexOutOfBoundsException("Attempt to access index " + var1 + " when valid range is 0.." + (this.myLength - 1));
  249.       }
  250.    }
  251.  
  252.    public synchronized void put(int var1, Object var2) {
  253.       if (var1 >= 0 && var1 < this.myLength) {
  254.          int var3 = this.myStart.myBlockIndex + var1;
  255.          int var4 = this.myStart.myMapIndex;
  256.          if (var3 >= BLOCK_SIZE) {
  257.             int var5 = var3 / BLOCK_SIZE;
  258.             var4 += var5;
  259.             var3 %= BLOCK_SIZE;
  260.          } else if (var3 < 0) {
  261.             int var6 = (BLOCK_SIZE - 1 - var3) / BLOCK_SIZE;
  262.             var4 -= var6;
  263.             var3 += var6 * BLOCK_SIZE;
  264.          }
  265.  
  266.          this.myMap[var4][var3] = var2;
  267.       } else {
  268.          throw new IndexOutOfBoundsException("Attempt to access index " + var1 + " when valid range is 0.." + (this.myLength - 1));
  269.       }
  270.    }
  271.  
  272.    public synchronized void swap(Deque var1) {
  273.       synchronized(var1){}
  274.  
  275.       try {
  276.          DequeIterator var4 = this.myStart;
  277.          this.myStart = var1.myStart;
  278.          this.myStart.myDeque = this;
  279.          var1.myStart = var4;
  280.          var1.myStart.myDeque = var1;
  281.          DequeIterator var5 = this.myFinish;
  282.          this.myFinish = var1.myFinish;
  283.          this.myFinish.myDeque = this;
  284.          var1.myFinish = var5;
  285.          var1.myFinish.myDeque = var1;
  286.          int var6 = this.myLength;
  287.          this.myLength = var1.myLength;
  288.          var1.myLength = var6;
  289.          Object[][] var7 = this.myMap;
  290.          this.myMap = var1.myMap;
  291.          var1.myMap = var7;
  292.       } catch (Throwable var9) {
  293.          throw var9;
  294.       }
  295.  
  296.    }
  297.  
  298.    public synchronized Object remove(int var1) {
  299.       if (var1 >= 0 && var1 < this.myLength) {
  300.          return this.remove((Enumeration)this.myStart.copy(var1));
  301.       } else {
  302.          throw new IndexOutOfBoundsException("Attempt to access index " + var1 + " when valid range is 0.." + (this.myLength - 1));
  303.       }
  304.    }
  305.  
  306.    public synchronized Object remove(Enumeration var1) {
  307.       if (!(var1 instanceof DequeIterator)) {
  308.          throw new IllegalArgumentException("Enumeration not a DequeIterator");
  309.       } else if (((DequeIterator)var1).myDeque != this) {
  310.          throw new IllegalArgumentException("Enumeration not for this Deque");
  311.       } else {
  312.          DequeIterator var2 = (DequeIterator)var1;
  313.          Object var3 = var2.myDeque.myMap[var2.myMapIndex][var2.myBlockIndex];
  314.          DequeIterator var4 = var2.copy(1);
  315.          if (this.myStart.distance(var2) < var2.distance(this.myFinish)) {
  316.             Copying.copy(var4, this.myFinish, var2);
  317.             this.popBack();
  318.          } else {
  319.             Copying.copyBackward(this.myStart, var2, var4);
  320.             this.popFront();
  321.          }
  322.  
  323.          return var3;
  324.       }
  325.    }
  326.  
  327.    public synchronized int remove(int var1, int var2) {
  328.       if (var2 < var1) {
  329.          return 0;
  330.       } else {
  331.          this.checkRange(var1, var2);
  332.          return this.remove(this.myStart.copy(var1), this.myStart.copy(var2 + 1));
  333.       }
  334.    }
  335.  
  336.    public synchronized int remove(Enumeration var1, Enumeration var2) {
  337.       if (var1 instanceof DequeIterator && var2 instanceof DequeIterator) {
  338.          if (((DequeIterator)var1).myDeque == this && ((DequeIterator)var2).myDeque == this) {
  339.             DequeIterator var3 = (DequeIterator)var1;
  340.             DequeIterator var4 = (DequeIterator)var2;
  341.             int var5 = var3.distance(var4);
  342.             int var6 = var5;
  343.             if (var4.distance(this.myFinish) > this.myStart.distance(var3)) {
  344.                Copying.copyBackward(this.myStart, var3, var4);
  345.  
  346.                while(var5-- > 0) {
  347.                   this.popFront();
  348.                }
  349.             } else {
  350.                Copying.copy(var4, this.myFinish, var3);
  351.  
  352.                while(var5-- > 0) {
  353.                   this.popBack();
  354.                }
  355.             }
  356.  
  357.             return var6;
  358.          } else {
  359.             throw new IllegalArgumentException("Enumeration not for this Deque");
  360.          }
  361.       } else {
  362.          throw new IllegalArgumentException("Enumeration not a DequeIterator");
  363.       }
  364.    }
  365.  
  366.    public synchronized DequeIterator insert(int var1, Object var2) {
  367.       if (var1 >= 0 && var1 <= this.myLength) {
  368.          return this.insert(this.myStart.copy(var1), var2);
  369.       } else {
  370.          throw new IndexOutOfBoundsException("Attempt to insert at index " + var1 + " when valid range is 0.." + this.myLength);
  371.       }
  372.    }
  373.  
  374.    public synchronized DequeIterator insert(DequeIterator var1, Object var2) {
  375.       if (var1.equals(this.myStart)) {
  376.          this.pushFront(var2);
  377.          return new DequeIterator(this.myStart);
  378.       } else if (var1.equals(this.myFinish)) {
  379.          this.pushBack(var2);
  380.          return this.myFinish.copy(-1);
  381.       } else {
  382.          int var3 = this.myStart.distance(var1);
  383.          if (var1.distance(this.myFinish) > var3) {
  384.             DequeIterator var6 = this.myStart;
  385.             this.pushFront(var6.myDeque.myMap[var6.myMapIndex][var6.myBlockIndex]);
  386.             Copying.copy(this.myStart.copy(2), this.myStart.copy(var3 + 1), this.myStart.copy(1));
  387.             var6 = this.myStart.copy(var3);
  388.             var6.myDeque.myMap[var6.myMapIndex][var6.myBlockIndex] = var2;
  389.             return var6;
  390.          } else {
  391.             DequeIterator var4 = this.myFinish.copy(-1);
  392.             this.pushBack(var4.myDeque.myMap[var4.myMapIndex][var4.myBlockIndex]);
  393.             DequeIterator var5 = this.myStart.copy(var3);
  394.             Copying.copyBackward(var5, this.myFinish.copy(-2), this.myFinish.copy(-1));
  395.             var5.myDeque.myMap[var5.myMapIndex][var5.myBlockIndex] = var2;
  396.             return var5;
  397.          }
  398.       }
  399.    }
  400.  
  401.    public synchronized void insert(int var1, int var2, Object var3) {
  402.       if (var2 < 0) {
  403.          throw new IllegalArgumentException("Attempt to insert a negative n1umber of objects.");
  404.       } else if (var1 >= 0 && var1 <= this.myLength) {
  405.          this.insert(this.myStart.copy(var1), var2, var3);
  406.       } else {
  407.          throw new IndexOutOfBoundsException("Attempt to insert at index " + var1 + " when valid range is 0.." + this.myLength);
  408.       }
  409.    }
  410.  
  411.    public synchronized void insert(DequeIterator var1, int var2, Object var3) {
  412.       if (var2 < 0) {
  413.          throw new IllegalArgumentException("Attempt to insert a negative number of objects");
  414.       } else if (var2 != 0) {
  415.          int var4 = this.myStart.distance(var1);
  416.          int var5 = var1.distance(this.myFinish);
  417.          if (var5 > var4) {
  418.             if (var2 > var4) {
  419.                int var11 = var2 - var4;
  420.  
  421.                while(var11-- > 0) {
  422.                   this.pushFront(var3);
  423.                }
  424.  
  425.                for(int var14 = 1; var14 <= var4; ++var14) {
  426.                   this.pushFront(this.method_0(var2 - 1));
  427.                }
  428.  
  429.                Filling.fill(this.myStart.copy(var2), this.myStart.copy(var2 + var4), var3);
  430.             } else {
  431.                for(int var10 = 1; var10 <= var2; ++var10) {
  432.                   this.pushFront(this.method_0(var2 - 1));
  433.                }
  434.  
  435.                DequeIterator var13 = this.myStart.copy(var2 + var4);
  436.                Copying.copy(this.myStart.copy(var2 + var2), var13, this.myStart.copy(var2));
  437.                Filling.fill(this.myStart.copy(var4), var13, var3);
  438.             }
  439.          } else {
  440.             int var6 = this.size();
  441.             if (var2 > var5) {
  442.                int var12 = var2 - var5;
  443.  
  444.                while(var12-- > 0) {
  445.                   this.pushBack(var3);
  446.                }
  447.  
  448.                for(int var15 = var4; var15 < var6; ++var15) {
  449.                   this.pushBack(this.method_0(var15));
  450.                }
  451.  
  452.                Filling.fill(this.myStart.copy(var4), this.myStart.copy(var6), var3);
  453.             } else {
  454.                int var7 = var6 - var2;
  455.  
  456.                for(int var8 = var7; var8 < var6; ++var8) {
  457.                   this.pushBack(this.method_0(var8));
  458.                }
  459.  
  460.                DequeIterator var9 = this.myStart.copy(var4);
  461.                Copying.copyBackward(var9, this.myStart.copy(var7), this.myStart.copy(var6));
  462.                Filling.fill(var9, this.myStart.copy(var4 + var2), var3);
  463.             }
  464.          }
  465.       }
  466.    }
  467.  
  468.    public synchronized void insert(int var1, BidirectionalIterator var2, BidirectionalIterator var3) {
  469.       if (var1 >= 0 && var1 <= this.myLength) {
  470.          this.insert(this.myStart.copy(var1), var2, var3);
  471.       } else {
  472.          throw new IndexOutOfBoundsException("Attempt to insert at index " + var1 + " when valid range is 0.." + this.myLength);
  473.       }
  474.    }
  475.  
  476.    public synchronized void insert(DequeIterator var1, BidirectionalIterator var2, BidirectionalIterator var3) {
  477.       int var4 = var2.distance(var3);
  478.       int var5 = this.myStart.distance(var1);
  479.       int var6 = var1.distance(this.myFinish);
  480.       if (var6 > var5) {
  481.          if (var4 > var5) {
  482.             BidirectionalIterator var12 = (BidirectionalIterator)var3.clone();
  483.             var12.retreat(var5);
  484.             BidirectionalIterator var14 = (BidirectionalIterator)var12.clone();
  485.  
  486.             while(!var12.equals(var2)) {
  487.                var12.retreat();
  488.                this.pushFront(var12.get());
  489.             }
  490.  
  491.             for(int var16 = 1; var16 <= var5; ++var16) {
  492.                this.pushFront(this.method_0(var4 - 1));
  493.             }
  494.  
  495.             Copying.copy(var14, var3, this.myStart.copy(var4));
  496.          } else {
  497.             for(int var11 = 1; var11 <= var4; ++var11) {
  498.                this.pushFront(this.method_0(var4 - 1));
  499.             }
  500.  
  501.             Copying.copy(this.myStart.copy(var4 + var4), this.myStart.copy(var4 + var5), this.myStart.copy(var4));
  502.             Copying.copy(var2, var3, this.myStart.copy(var5));
  503.          }
  504.       } else {
  505.          int var7 = this.size();
  506.          if (var4 > var6) {
  507.             BidirectionalIterator var13 = (BidirectionalIterator)var2.clone();
  508.             var13.advance(var6);
  509.             BidirectionalIterator var15 = (BidirectionalIterator)var13.clone();
  510.  
  511.             while(!var13.equals(var3)) {
  512.                this.pushBack(var13.nextElement());
  513.             }
  514.  
  515.             for(int var17 = var5; var17 < var7; ++var17) {
  516.                this.pushBack(this.method_0(var17));
  517.             }
  518.  
  519.             Copying.copy(var2, var15, this.myStart.copy(var5));
  520.          } else {
  521.             int var8 = var7 - var4;
  522.  
  523.             for(int var9 = var8; var9 < var7; ++var9) {
  524.                this.pushBack(this.method_0(var9));
  525.             }
  526.  
  527.             DequeIterator var10 = this.myStart.copy(var5);
  528.             Copying.copyBackward(var10, this.myStart.copy(var8), this.myStart.copy(var7));
  529.             Copying.copy(var2, var3, this.myStart.copy(var5));
  530.          }
  531.       }
  532.    }
  533.  
  534.    public int remove(Object var1) {
  535.       return this.remove(0, this.myLength - 1, var1);
  536.    }
  537.  
  538.    public synchronized int remove(Object var1, int var2) {
  539.       int var3 = 0;
  540.  
  541.       while(var2 > 0) {
  542.          int var4 = this.indexOf(var1);
  543.          if (var4 >= 0) {
  544.             --var2;
  545.             ++var3;
  546.             this.remove(var4);
  547.          }
  548.       }
  549.  
  550.       return var3;
  551.    }
  552.  
  553.    public synchronized int remove(int var1, int var2, Object var3) {
  554.       if (var2 < var1) {
  555.          return 0;
  556.       } else {
  557.          this.checkRange(var1, var2);
  558.          DequeIterator var4 = this.myStart.copy(var1);
  559.          DequeIterator var5 = this.myStart.copy(var2 + 1);
  560.          DequeIterator var6 = (DequeIterator)Removing.remove(var4, var5, var3);
  561.          int var7 = var6.distance(var5);
  562.          this.remove(var6, var5);
  563.          return var7;
  564.       }
  565.    }
  566.  
  567.    public synchronized int replace(Object var1, Object var2) {
  568.       return Replacing.replace(this.start(), this.finish(), var1, var2);
  569.    }
  570.  
  571.    public synchronized int replace(int var1, int var2, Object var3, Object var4) {
  572.       if (var2 < var1) {
  573.          return 0;
  574.       } else {
  575.          this.checkRange(var1, var2);
  576.          return Replacing.replace(this.myStart.copy(var1), this.myStart.copy(var2 + 1), var3, var4);
  577.       }
  578.    }
  579.  
  580.    public synchronized int count(Object var1) {
  581.       return Counting.count(this.start(), this.finish(), var1);
  582.    }
  583.  
  584.    public synchronized int count(int var1, int var2, Object var3) {
  585.       if (var2 < var1) {
  586.          return 0;
  587.       } else {
  588.          this.checkRange(var1, var2);
  589.          return Counting.count(this.myStart.copy(var1), this.myStart.copy(var2 + 1), var3);
  590.       }
  591.    }
  592.  
  593.    public synchronized int indexOf(Object var1) {
  594.       DequeIterator var2 = (DequeIterator)Finding.find(this.myStart, this.myFinish, var1);
  595.       return var2.equals(var2.myDeque.myFinish) ? -1 : this.myStart.distance(var2);
  596.    }
  597.  
  598.    public synchronized int indexOf(int var1, int var2, Object var3) {
  599.       if (var2 < var1) {
  600.          return -1;
  601.       } else {
  602.          this.checkRange(var1, var2);
  603.          DequeIterator var4 = this.myStart.copy(var2 + 1);
  604.          DequeIterator var5 = (DequeIterator)Finding.find(this.myStart.copy(var1), var4, var3);
  605.          return var5.equals(var4) ? -1 : this.myStart.distance(var5);
  606.       }
  607.    }
  608.  
  609.    public boolean contains(Object var1) {
  610.       return this.indexOf(var1) != -1;
  611.    }
  612.  
  613.    private void growMap() {
  614.       int var1 = this.myMap.length * 2;
  615.       Object[][] var2 = new Object[var1][];
  616.       int var3 = var1 / 4;
  617.       int var4 = this.myFinish.myMapIndex - this.myStart.myMapIndex + 1;
  618.       System.arraycopy(this.myMap, this.myStart.myMapIndex, var2, var3, var4);
  619.       this.myFinish.myMapIndex = var3;
  620.       this.myStart.myMapIndex = var3 + var4 - 1;
  621.       this.myMap = var2;
  622.    }
  623.  
  624.    private void createMap() {
  625.       this.myMap = new Object[1024][];
  626.       int var1 = this.myMap.length / 2;
  627.       this.myMap[var1] = new Object[BLOCK_SIZE];
  628.       int var2 = BLOCK_SIZE / 2;
  629.       this.myStart.myBlockIndex = var2;
  630.       this.myStart.myMapIndex = var1;
  631.       this.myFinish.myBlockIndex = var2;
  632.       this.myFinish.myMapIndex = var1;
  633.    }
  634.  
  635.    private void checkRange(int var1, int var2) {
  636.       if (var1 >= 0 && var1 < this.myLength) {
  637.          if (var2 < 0 || var2 >= this.myLength) {
  638.             throw new IndexOutOfBoundsException("Attempt to access index " + var2 + " when valid range is 0.." + (this.myLength - 1));
  639.          }
  640.       } else {
  641.          throw new IndexOutOfBoundsException("Attempt to access index " + var1 + " when valid range is 0.." + (this.myLength - 1));
  642.       }
  643.    }
  644. }
  645.