[cvs] / jsr166 / src / main / java / util / concurrent / LinkedTransferQueue.java Repository:
ViewVC logotype

Diff of /jsr166/src/main/java/util/concurrent/LinkedTransferQueue.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.81, Wed Feb 18 06:39:40 2015 UTC revision 1.82, Fri Feb 20 03:09:08 2015 UTC
# Line 7  Line 7 
7  package java.util.concurrent;  package java.util.concurrent;
8    
9  import java.util.AbstractQueue;  import java.util.AbstractQueue;
10    import java.util.Arrays;
11  import java.util.Collection;  import java.util.Collection;
12  import java.util.Iterator;  import java.util.Iterator;
13  import java.util.NoSuchElementException;  import java.util.NoSuchElementException;
# Line 800  Line 801 
801          }          }
802      }      }
803    
804        public String toString() {
805            String[] a = null;
806            restartFromHead: for (;;) {
807                int charLength = 0;
808                int size = 0;
809                for (Node p = head; p != null;) {
810                    Object item = p.item;
811                    if (p.isData) {
812                        if (item != null && item != p) {
813                            if (a == null)
814                                a = new String[4];
815                            else if (size == a.length)
816                                a = Arrays.copyOf(a, 2 * size);
817                            String s = item.toString();
818                            a[size++] = s;
819                            charLength += s.length();
820                        }
821                    } else if (item == null)
822                        break;
823                    if (p == (p = p.next))
824                        continue restartFromHead;
825                }
826    
827                if (size == 0)
828                    return "[]";
829    
830                // Copy each string into a perfectly sized char[]
831                final char[] chars = new char[charLength + 2 * size];
832                chars[0] = '[';
833                int j = 1;
834                for (int i = 0; i < size; i++) {
835                    if (i > 0) {
836                        chars[j++] = ',';
837                        chars[j++] = ' ';
838                    }
839                    String s = a[i];
840                    int len = s.length();
841                    s.getChars(0, len, chars, j);
842                    j += len;
843                }
844                chars[j] = ']';
845                return new String(chars);
846            }
847        }
848    
849        private Object[] toArrayInternal(Object[] a) {
850            Object[] x = a;
851            restartFromHead: for (;;) {
852                int size = 0;
853                for (Node p = head; p != null;) {
854                    Object item = p.item;
855                    if (p.isData) {
856                        if (item != null && item != p) {
857                            if (x == null)
858                                x = new Object[4];
859                            else if (size == x.length)
860                                x = Arrays.copyOf(x, 2 * (size + 4));
861                            x[size++] = item;
862                        }
863                    } else if (item == null)
864                        break;
865                    if (p == (p = p.next))
866                        continue restartFromHead;
867                }
868                if (x == null)
869                    return new Object[0];
870                else if (a != null && size <= a.length) {
871                    if (a != x)
872                        System.arraycopy(x, 0, a, 0, size);
873                    if (size < a.length)
874                        a[size] = null;
875                    return a;
876                }
877                return (size == x.length) ? x : Arrays.copyOf(x, size);
878            }
879        }
880    
881        /**
882         * Returns an array containing all of the elements in this queue, in
883         * proper sequence.
884         *
885         * <p>The returned array will be "safe" in that no references to it are
886         * maintained by this queue.  (In other words, this method must allocate
887         * a new array).  The caller is thus free to modify the returned array.
888         *
889         * <p>This method acts as bridge between array-based and collection-based
890         * APIs.
891         *
892         * @return an array containing all of the elements in this queue
893         */
894        public Object[] toArray() {
895            return toArrayInternal(null);
896        }
897    
898        /**
899         * Returns an array containing all of the elements in this queue, in
900         * proper sequence; the runtime type of the returned array is that of
901         * the specified array.  If the queue fits in the specified array, it
902         * is returned therein.  Otherwise, a new array is allocated with the
903         * runtime type of the specified array and the size of this queue.
904         *
905         * <p>If this queue fits in the specified array with room to spare
906         * (i.e., the array has more elements than this queue), the element in
907         * the array immediately following the end of the queue is set to
908         * {@code null}.
909         *
910         * <p>Like the {@link #toArray()} method, this method acts as bridge between
911         * array-based and collection-based APIs.  Further, this method allows
912         * precise control over the runtime type of the output array, and may,
913         * under certain circumstances, be used to save allocation costs.
914         *
915         * <p>Suppose {@code x} is a queue known to contain only strings.
916         * The following code can be used to dump the queue into a newly
917         * allocated array of {@code String}:
918         *
919         * <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
920         *
921         * Note that {@code toArray(new Object[0])} is identical in function to
922         * {@code toArray()}.
923         *
924         * @param a the array into which the elements of the queue are to
925         *          be stored, if it is big enough; otherwise, a new array of the
926         *          same runtime type is allocated for this purpose
927         * @return an array containing all of the elements in this queue
928         * @throws ArrayStoreException if the runtime type of the specified array
929         *         is not a supertype of the runtime type of every element in
930         *         this queue
931         * @throws NullPointerException if the specified array is null
932         */
933        @SuppressWarnings("unchecked")
934        public <T> T[] toArray(T[] a) {
935            if (a == null) throw new NullPointerException();
936            return (T[]) toArrayInternal(a);
937        }
938    
939      final class Itr implements Iterator<E> {      final class Itr implements Iterator<E> {
940          private Node nextNode;   // next node to return item for          private Node nextNode;   // next node to return item for
941          private E nextItem;      // the corresponding item          private E nextItem;      // the corresponding item

Legend:
Removed from v.1.81  
changed lines
  Added in v.1.82

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8