home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / util / ArrayDeque.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  6.1 KB  |  427 lines
  1. package java.util;
  2.  
  3. import java.io.IOException;
  4. import java.io.ObjectInputStream;
  5. import java.io.ObjectOutputStream;
  6. import java.io.Serializable;
  7. import java.lang.reflect.Array;
  8.  
  9. public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable {
  10.    private transient E[] elements;
  11.    private transient int head;
  12.    private transient int tail;
  13.    private static final int MIN_INITIAL_CAPACITY = 8;
  14.    private static final long serialVersionUID = 2340985798034038923L;
  15.  
  16.    private void allocateElements(int var1) {
  17.       int var7 = 8;
  18.       if (var1 >= var7) {
  19.          int var3 = var1 | var1 >>> 1;
  20.          int var4 = var3 | var3 >>> 2;
  21.          int var5 = var4 | var4 >>> 4;
  22.          int var6 = var5 | var5 >>> 8;
  23.          var7 = var6 | var6 >>> 16;
  24.          ++var7;
  25.          if (var7 < 0) {
  26.             var7 >>>= 1;
  27.          }
  28.       }
  29.  
  30.       this.elements = (E[])(new Object[var7]);
  31.    }
  32.  
  33.    private void doubleCapacity() {
  34.       assert this.head == this.tail;
  35.  
  36.       int var1 = this.head;
  37.       int var2 = this.elements.length;
  38.       int var3 = var2 - var1;
  39.       int var4 = var2 << 1;
  40.       if (var4 < 0) {
  41.          throw new IllegalStateException("Sorry, deque too big");
  42.       } else {
  43.          Object[] var5 = new Object[var4];
  44.          System.arraycopy(this.elements, var1, var5, 0, var3);
  45.          System.arraycopy(this.elements, 0, var5, var3, var1);
  46.          this.elements = (E[])(var5);
  47.          this.head = 0;
  48.          this.tail = var2;
  49.       }
  50.    }
  51.  
  52.    private <T> T[] copyElements(T[] var1) {
  53.       if (this.head < this.tail) {
  54.          System.arraycopy(this.elements, this.head, var1, 0, this.size());
  55.       } else if (this.head > this.tail) {
  56.          int var2 = this.elements.length - this.head;
  57.          System.arraycopy(this.elements, this.head, var1, 0, var2);
  58.          System.arraycopy(this.elements, 0, var1, var2, this.tail);
  59.       }
  60.  
  61.       return (T[])var1;
  62.    }
  63.  
  64.    public ArrayDeque() {
  65.       this.elements = (E[])(new Object[16]);
  66.    }
  67.  
  68.    public ArrayDeque(int var1) {
  69.       this.allocateElements(var1);
  70.    }
  71.  
  72.    public ArrayDeque(Collection<? extends E> var1) {
  73.       this.allocateElements(var1.size());
  74.       this.addAll(var1);
  75.    }
  76.  
  77.    public void addFirst(E var1) {
  78.       if (var1 == null) {
  79.          throw new NullPointerException();
  80.       } else {
  81.          this.elements[this.head = this.head - 1 & this.elements.length - 1] = var1;
  82.          if (this.head == this.tail) {
  83.             this.doubleCapacity();
  84.          }
  85.  
  86.       }
  87.    }
  88.  
  89.    public void addLast(E var1) {
  90.       if (var1 == null) {
  91.          throw new NullPointerException();
  92.       } else {
  93.          this.elements[this.tail] = var1;
  94.          if ((this.tail = this.tail + 1 & this.elements.length - 1) == this.head) {
  95.             this.doubleCapacity();
  96.          }
  97.  
  98.       }
  99.    }
  100.  
  101.    public boolean offerFirst(E var1) {
  102.       this.addFirst(var1);
  103.       return true;
  104.    }
  105.  
  106.    public boolean offerLast(E var1) {
  107.       this.addLast(var1);
  108.       return true;
  109.    }
  110.  
  111.    public E removeFirst() {
  112.       Object var1 = this.pollFirst();
  113.       if (var1 == null) {
  114.          throw new NoSuchElementException();
  115.       } else {
  116.          return (E)var1;
  117.       }
  118.    }
  119.  
  120.    public E removeLast() {
  121.       Object var1 = this.pollLast();
  122.       if (var1 == null) {
  123.          throw new NoSuchElementException();
  124.       } else {
  125.          return (E)var1;
  126.       }
  127.    }
  128.  
  129.    public E pollFirst() {
  130.       int var1 = this.head;
  131.       Object var2 = this.elements[var1];
  132.       if (var2 == null) {
  133.          return null;
  134.       } else {
  135.          this.elements[var1] = null;
  136.          this.head = var1 + 1 & this.elements.length - 1;
  137.          return (E)var2;
  138.       }
  139.    }
  140.  
  141.    public E pollLast() {
  142.       int var1 = this.tail - 1 & this.elements.length - 1;
  143.       Object var2 = this.elements[var1];
  144.       if (var2 == null) {
  145.          return null;
  146.       } else {
  147.          this.elements[var1] = null;
  148.          this.tail = var1;
  149.          return (E)var2;
  150.       }
  151.    }
  152.  
  153.    public E getFirst() {
  154.       Object var1 = this.elements[this.head];
  155.       if (var1 == null) {
  156.          throw new NoSuchElementException();
  157.       } else {
  158.          return (E)var1;
  159.       }
  160.    }
  161.  
  162.    public E getLast() {
  163.       Object var1 = this.elements[this.tail - 1 & this.elements.length - 1];
  164.       if (var1 == null) {
  165.          throw new NoSuchElementException();
  166.       } else {
  167.          return (E)var1;
  168.       }
  169.    }
  170.  
  171.    public E peekFirst() {
  172.       return (E)this.elements[this.head];
  173.    }
  174.  
  175.    public E peekLast() {
  176.       return (E)this.elements[this.tail - 1 & this.elements.length - 1];
  177.    }
  178.  
  179.    public boolean removeFirstOccurrence(Object var1) {
  180.       if (var1 == null) {
  181.          return false;
  182.       } else {
  183.          int var2 = this.elements.length - 1;
  184.  
  185.          Object var4;
  186.          for(int var3 = this.head; (var4 = this.elements[var3]) != null; var3 = var3 + 1 & var2) {
  187.             if (var1.equals(var4)) {
  188.                this.delete(var3);
  189.                return true;
  190.             }
  191.          }
  192.  
  193.          return false;
  194.       }
  195.    }
  196.  
  197.    public boolean removeLastOccurrence(Object var1) {
  198.       if (var1 == null) {
  199.          return false;
  200.       } else {
  201.          int var2 = this.elements.length - 1;
  202.  
  203.          Object var4;
  204.          for(int var3 = this.tail - 1 & var2; (var4 = this.elements[var3]) != null; var3 = var3 - 1 & var2) {
  205.             if (var1.equals(var4)) {
  206.                this.delete(var3);
  207.                return true;
  208.             }
  209.          }
  210.  
  211.          return false;
  212.       }
  213.    }
  214.  
  215.    public boolean add(E var1) {
  216.       this.addLast(var1);
  217.       return true;
  218.    }
  219.  
  220.    public boolean offer(E var1) {
  221.       return this.offerLast(var1);
  222.    }
  223.  
  224.    public E remove() {
  225.       return (E)this.removeFirst();
  226.    }
  227.  
  228.    public E poll() {
  229.       return (E)this.pollFirst();
  230.    }
  231.  
  232.    public E element() {
  233.       return (E)this.getFirst();
  234.    }
  235.  
  236.    public E peek() {
  237.       return (E)this.peekFirst();
  238.    }
  239.  
  240.    public void push(E var1) {
  241.       this.addFirst(var1);
  242.    }
  243.  
  244.    public E pop() {
  245.       return (E)this.removeFirst();
  246.    }
  247.  
  248.    private void checkInvariants() {
  249.       assert this.elements[this.tail] == null;
  250.  
  251.       if (!$assertionsDisabled) {
  252.          if (this.head == this.tail) {
  253.             if (this.elements[this.head] != null) {
  254.                throw new AssertionError();
  255.             }
  256.          } else if (this.elements[this.head] == null || this.elements[this.tail - 1 & this.elements.length - 1] == null) {
  257.             throw new AssertionError();
  258.          }
  259.       }
  260.  
  261.       assert this.elements[this.head - 1 & this.elements.length - 1] == null;
  262.  
  263.    }
  264.  
  265.    private boolean delete(int var1) {
  266.       this.checkInvariants();
  267.       Object[] var2 = this.elements;
  268.       int var3 = var2.length - 1;
  269.       int var4 = this.head;
  270.       int var5 = this.tail;
  271.       int var6 = var1 - var4 & var3;
  272.       int var7 = var5 - var1 & var3;
  273.       if (var6 >= (var5 - var4 & var3)) {
  274.          throw new ConcurrentModificationException();
  275.       } else if (var6 < var7) {
  276.          if (var4 <= var1) {
  277.             System.arraycopy(var2, var4, var2, var4 + 1, var6);
  278.          } else {
  279.             System.arraycopy(var2, 0, var2, 1, var1);
  280.             var2[0] = var2[var3];
  281.             System.arraycopy(var2, var4, var2, var4 + 1, var3 - var4);
  282.          }
  283.  
  284.          var2[var4] = null;
  285.          this.head = var4 + 1 & var3;
  286.          return false;
  287.       } else {
  288.          if (var1 < var5) {
  289.             System.arraycopy(var2, var1 + 1, var2, var1, var7);
  290.             this.tail = var5 - 1;
  291.          } else {
  292.             System.arraycopy(var2, var1 + 1, var2, var1, var3 - var1);
  293.             var2[var3] = var2[0];
  294.             System.arraycopy(var2, 1, var2, 0, var5);
  295.             this.tail = var5 - 1 & var3;
  296.          }
  297.  
  298.          return true;
  299.       }
  300.    }
  301.  
  302.    public int size() {
  303.       return this.tail - this.head & this.elements.length - 1;
  304.    }
  305.  
  306.    public boolean isEmpty() {
  307.       return this.head == this.tail;
  308.    }
  309.  
  310.    public Iterator<E> iterator() {
  311.       return new DeqIterator(this, (1)null);
  312.    }
  313.  
  314.    public Iterator<E> descendingIterator() {
  315.       return new DescendingIterator(this, (1)null);
  316.    }
  317.  
  318.    public boolean contains(Object var1) {
  319.       if (var1 == null) {
  320.          return false;
  321.       } else {
  322.          int var2 = this.elements.length - 1;
  323.  
  324.          Object var4;
  325.          for(int var3 = this.head; (var4 = this.elements[var3]) != null; var3 = var3 + 1 & var2) {
  326.             if (var1.equals(var4)) {
  327.                return true;
  328.             }
  329.          }
  330.  
  331.          return false;
  332.       }
  333.    }
  334.  
  335.    public boolean remove(Object var1) {
  336.       return this.removeFirstOccurrence(var1);
  337.    }
  338.  
  339.    public void clear() {
  340.       int var1 = this.head;
  341.       int var2 = this.tail;
  342.       if (var1 != var2) {
  343.          this.head = this.tail = 0;
  344.          int var3 = var1;
  345.          int var4 = this.elements.length - 1;
  346.  
  347.          do {
  348.             this.elements[var3] = null;
  349.             var3 = var3 + 1 & var4;
  350.          } while(var3 != var2);
  351.       }
  352.  
  353.    }
  354.  
  355.    public Object[] toArray() {
  356.       return this.copyElements(new Object[this.size()]);
  357.    }
  358.  
  359.    public <T> T[] toArray(T[] var1) {
  360.       int var2 = this.size();
  361.       if (var1.length < var2) {
  362.          var1 = Array.newInstance(var1.getClass().getComponentType(), var2);
  363.       }
  364.  
  365.       this.copyElements(var1);
  366.       if (var1.length > var2) {
  367.          var1[var2] = null;
  368.       }
  369.  
  370.       return (T[])var1;
  371.    }
  372.  
  373.    public ArrayDeque<E> clone() {
  374.       try {
  375.          ArrayDeque var1 = (ArrayDeque)super.clone();
  376.          var1.elements = (E[])Arrays.copyOf(this.elements, this.elements.length);
  377.          return var1;
  378.       } catch (CloneNotSupportedException var2) {
  379.          throw new AssertionError();
  380.       }
  381.    }
  382.  
  383.    private void writeObject(ObjectOutputStream var1) throws IOException {
  384.       var1.defaultWriteObject();
  385.       var1.writeInt(this.size());
  386.       int var2 = this.elements.length - 1;
  387.  
  388.       for(int var3 = this.head; var3 != this.tail; var3 = var3 + 1 & var2) {
  389.          var1.writeObject(this.elements[var3]);
  390.       }
  391.  
  392.    }
  393.  
  394.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  395.       var1.defaultReadObject();
  396.       int var2 = var1.readInt();
  397.       this.allocateElements(var2);
  398.       this.head = 0;
  399.       this.tail = var2;
  400.  
  401.       for(int var3 = 0; var3 < var2; ++var3) {
  402.          this.elements[var3] = var1.readObject();
  403.       }
  404.  
  405.    }
  406.  
  407.    // $FF: synthetic method
  408.    static int access$200(ArrayDeque var0) {
  409.       return var0.head;
  410.    }
  411.  
  412.    // $FF: synthetic method
  413.    static int access$300(ArrayDeque var0) {
  414.       return var0.tail;
  415.    }
  416.  
  417.    // $FF: synthetic method
  418.    static Object[] access$400(ArrayDeque var0) {
  419.       return var0.elements;
  420.    }
  421.  
  422.    // $FF: synthetic method
  423.    static boolean access$500(ArrayDeque var0, int var1) {
  424.       return var0.delete(var1);
  425.    }
  426. }
  427.