| 436 |
|
if (o != null) { |
| 437 |
|
final Object[] elements = this.elements; |
| 438 |
|
final int capacity = elements.length; |
| 439 |
< |
int from, end, to, leftover; |
| 440 |
< |
leftover = (end = (from = head) + size) |
| 439 |
> |
int from, end, to, todo; |
| 440 |
> |
todo = (end = (from = head) + size) |
| 441 |
|
- (to = (capacity - end >= 0) ? end : capacity); |
| 442 |
< |
for (;; from = 0, to = leftover, leftover = 0) { |
| 442 |
> |
for (;; from = 0, to = todo, todo = 0) { |
| 443 |
|
for (int i = from; i < to; i++) |
| 444 |
|
if (o.equals(elements[i])) { |
| 445 |
|
delete(i); |
| 446 |
|
return true; |
| 447 |
|
} |
| 448 |
< |
if (leftover == 0) break; |
| 448 |
> |
if (todo == 0) break; |
| 449 |
|
} |
| 450 |
|
} |
| 451 |
|
return false; |
| 467 |
|
if (o != null) { |
| 468 |
|
final Object[] elements = this.elements; |
| 469 |
|
final int capacity = elements.length; |
| 470 |
< |
int from, to, end, leftover; |
| 471 |
< |
leftover = (to = ((end = (from = tail()) - size) >= -1) ? end : -1) - end; |
| 472 |
< |
for (;; from = capacity - 1, to = capacity - 1 - leftover, leftover = 0) { |
| 470 |
> |
int from, to, end, todo; |
| 471 |
> |
todo = (to = ((end = (from = tail()) - size) >= -1) ? end : -1) - end; |
| 472 |
> |
for (;; from = capacity - 1, to = capacity - 1 - todo, todo = 0) { |
| 473 |
|
for (int i = from; i > to; i--) |
| 474 |
|
if (o.equals(elements[i])) { |
| 475 |
|
delete(i); |
| 476 |
|
return true; |
| 477 |
|
} |
| 478 |
< |
if (leftover == 0) break; |
| 478 |
> |
if (todo == 0) break; |
| 479 |
|
} |
| 480 |
|
} |
| 481 |
|
return false; |
| 849 |
|
Objects.requireNonNull(action); |
| 850 |
|
final Object[] elements = this.elements; |
| 851 |
|
final int capacity = elements.length; |
| 852 |
< |
int from, end, to, leftover; |
| 853 |
< |
leftover = (end = (from = head) + size) |
| 852 |
> |
int from, end, to, todo; |
| 853 |
> |
todo = (end = (from = head) + size) |
| 854 |
|
- (to = (capacity - end >= 0) ? end : capacity); |
| 855 |
< |
for (;; from = 0, to = leftover, leftover = 0) { |
| 855 |
> |
for (;; from = 0, to = todo, todo = 0) { |
| 856 |
|
for (int i = from; i < to; i++) |
| 857 |
|
action.accept((E) elements[i]); |
| 858 |
< |
if (leftover == 0) break; |
| 858 |
> |
if (todo == 0) break; |
| 859 |
|
} |
| 860 |
|
// checkInvariants(); |
| 861 |
|
} |
| 865 |
|
* modification, for use in iterators. |
| 866 |
|
*/ |
| 867 |
|
static <E> void forEachRemaining( |
| 868 |
< |
Consumer<? super E> action, Object[] elements, int from, int size) { |
| 868 |
> |
Consumer<? super E> action, Object[] elements, int from, int remaining) { |
| 869 |
|
Objects.requireNonNull(action); |
| 870 |
|
final int capacity = elements.length; |
| 871 |
< |
int end, to, leftover; |
| 872 |
< |
leftover = (end = from + size) |
| 871 |
> |
int end, to, todo; |
| 872 |
> |
todo = (end = from + remaining) |
| 873 |
|
- (to = (capacity - end >= 0) ? end : capacity); |
| 874 |
< |
for (;; from = 0, to = leftover, leftover = 0) { |
| 874 |
> |
for (;; from = 0, to = todo, todo = 0) { |
| 875 |
|
for (int i = from; i < to; i++) { |
| 876 |
|
@SuppressWarnings("unchecked") E e = (E) elements[i]; |
| 877 |
|
if (e == null) |
| 878 |
|
throw new ConcurrentModificationException(); |
| 879 |
|
action.accept(e); |
| 880 |
|
} |
| 881 |
< |
if (leftover == 0) break; |
| 881 |
> |
if (todo == 0) break; |
| 882 |
|
} |
| 883 |
|
} |
| 884 |
|
|
| 885 |
|
static <E> void forEachRemainingDescending( |
| 886 |
< |
Consumer<? super E> action, Object[] elements, int from, int size) { |
| 886 |
> |
Consumer<? super E> action, Object[] elements, int from, int remaining) { |
| 887 |
|
Objects.requireNonNull(action); |
| 888 |
|
final int capacity = elements.length; |
| 889 |
< |
int end, to, leftover; |
| 890 |
< |
leftover = (to = ((end = from - size) >= -1) ? end : -1) - end; |
| 891 |
< |
for (;; from = capacity - 1, to = capacity - 1 - leftover, leftover = 0) { |
| 889 |
> |
int end, to, todo; |
| 890 |
> |
todo = (to = ((end = from - remaining) >= -1) ? end : -1) - end; |
| 891 |
> |
for (;; from = capacity - 1, to = capacity - 1 - todo, todo = 0) { |
| 892 |
|
for (int i = from; i > to; i--) { |
| 893 |
|
@SuppressWarnings("unchecked") E e = (E) elements[i]; |
| 894 |
|
if (e == null) |
| 895 |
|
throw new ConcurrentModificationException(); |
| 896 |
|
action.accept(e); |
| 897 |
|
} |
| 898 |
< |
if (leftover == 0) break; |
| 898 |
> |
if (todo == 0) break; |
| 899 |
|
} |
| 900 |
|
} |
| 901 |
|
|
| 910 |
|
Objects.requireNonNull(operator); |
| 911 |
|
final Object[] elements = this.elements; |
| 912 |
|
final int capacity = elements.length; |
| 913 |
< |
int from, end, to, leftover; |
| 914 |
< |
leftover = (end = (from = head) + size) |
| 913 |
> |
int from, end, to, todo; |
| 914 |
> |
todo = (end = (from = head) + size) |
| 915 |
|
- (to = (capacity - end >= 0) ? end : capacity); |
| 916 |
< |
for (;; from = 0, to = leftover, leftover = 0) { |
| 916 |
> |
for (;; from = 0, to = todo, todo = 0) { |
| 917 |
|
for (int i = from; i < to; i++) |
| 918 |
|
elements[i] = operator.apply(elementAt(i)); |
| 919 |
< |
if (leftover == 0) break; |
| 919 |
> |
if (todo == 0) break; |
| 920 |
|
} |
| 921 |
|
// checkInvariants(); |
| 922 |
|
} |
| 991 |
|
if (o != null) { |
| 992 |
|
final Object[] elements = this.elements; |
| 993 |
|
final int capacity = elements.length; |
| 994 |
< |
int from, end, to, leftover; |
| 995 |
< |
leftover = (end = (from = head) + size) |
| 994 |
> |
int from, end, to, todo; |
| 995 |
> |
todo = (end = (from = head) + size) |
| 996 |
|
- (to = (capacity - end >= 0) ? end : capacity); |
| 997 |
< |
for (;; from = 0, to = leftover, leftover = 0) { |
| 997 |
> |
for (;; from = 0, to = todo, todo = 0) { |
| 998 |
|
for (int i = from; i < to; i++) |
| 999 |
|
if (o.equals(elements[i])) |
| 1000 |
|
return true; |
| 1001 |
< |
if (leftover == 0) break; |
| 1001 |
> |
if (todo == 0) break; |
| 1002 |
|
} |
| 1003 |
|
} |
| 1004 |
|
return false; |
| 1032 |
|
} |
| 1033 |
|
|
| 1034 |
|
/** |
| 1035 |
< |
* Nulls out size elements, starting at head. |
| 1035 |
> |
* Nulls out count elements, starting at array index from. |
| 1036 |
|
*/ |
| 1037 |
< |
private static void clearSlice(Object[] elements, int head, int size) { |
| 1038 |
< |
final int capacity = elements.length, end = head + size; |
| 1037 |
> |
private static void clearSlice(Object[] elements, int from, int count) { |
| 1038 |
> |
final int capacity = elements.length, end = from + count; |
| 1039 |
|
final int leg = (capacity - end >= 0) ? end : capacity; |
| 1040 |
< |
Arrays.fill(elements, head, leg, null); |
| 1040 |
> |
Arrays.fill(elements, from, leg, null); |
| 1041 |
|
if (leg != end) |
| 1042 |
|
Arrays.fill(elements, 0, end - capacity, null); |
| 1043 |
|
} |
| 1168 |
|
// Write out elements in order. |
| 1169 |
|
final Object[] elements = this.elements; |
| 1170 |
|
final int capacity = elements.length; |
| 1171 |
< |
int from, end, to, leftover; |
| 1172 |
< |
leftover = (end = (from = head) + size) |
| 1171 |
> |
int from, end, to, todo; |
| 1172 |
> |
todo = (end = (from = head) + size) |
| 1173 |
|
- (to = (capacity - end >= 0) ? end : capacity); |
| 1174 |
< |
for (;; from = 0, to = leftover, leftover = 0) { |
| 1174 |
> |
for (;; from = 0, to = todo, todo = 0) { |
| 1175 |
|
for (int i = from; i < to; i++) |
| 1176 |
|
s.writeObject(elements[i]); |
| 1177 |
< |
if (leftover == 0) break; |
| 1177 |
> |
if (todo == 0) break; |
| 1178 |
|
} |
| 1179 |
|
} |
| 1180 |
|
|
