Searched refs:tail (Results 1 - 13 of 13) sorted by relevance

/libcore/support/src/test/java/org/apache/harmony/security/tests/support/
H A DTestUtils.java52 String tail = Integer.toHexString(0x000000ff & data[i]);
53 if (tail.length() == 1) {
54 tail = "0" + tail;
56 System.out.print(prefix + "0x" + tail + delimiter);
/libcore/ojluni/src/main/java/java/util/
H A DArrayDeque.java95 * thus avoiding head and tail wrapping around to equal each
104 * arbitrary number equal to tail if the deque is empty.
109 * The index at which the next element would be added to the tail
112 transient int tail; field in class:ArrayDeque
148 * when head and tail have wrapped around to become equal.
151 assert head == tail;
163 tail = n;
213 if (head == tail)
228 elements[tail] = e;
229 if ( (tail
[all...]
/libcore/ojluni/src/main/java/java/lang/ref/
H A DReferenceQueue.java47 private Reference<? extends T> tail = null; field in class:ReferenceQueue
83 if (tail == null) {
86 tail.queueNext = r;
88 tail = r;
89 tail.queueNext = r;
124 if (head == tail) {
125 tail = null;
/libcore/luni/src/main/java/java/util/concurrent/
H A DConcurrentLinkedQueue.java29 * The <em>tail</em> of the queue is that element that has been on the
31 * are inserted at the tail of the queue, and the queue retrieval
97 * reached in O(1) time from tail, but tail is merely an
121 * Both head and tail are permitted to lag. In fact, failing to
125 * that is, we update head/tail when the current pointer appears
128 * Since head and tail are updated concurrently and independently,
129 * it is possible for tail to lag behind head (why not)?
144 * Both head and tail may or may not point to a Node with a
146 * be null. Upon creation, both head and tail refe
205 private transient volatile Node<E> tail; field in class:ConcurrentLinkedQueue
[all...]
H A DSynchronousQueue.java121 * cancelled. But if it may be pinned as the current tail, it must
568 transient volatile QNode tail; field in class:SynchronousQueue.TransferQueue
579 tail = h;
593 * Tries to cas nt as new tail.
596 if (tail == t)
626 * advance head and tail on behalf of other stalled/slow
630 * seeing uninitialized head or tail values. This never
642 QNode t = tail;
649 if (t != tail) // inconsistent read
651 if (tn != null) { // lagging tail
[all...]
H A DConcurrentLinkedDeque.java119 * The deque object has two node references, "head" and "tail".
120 * The head and tail are only approximations to the first and last
122 * following prev pointers from head; likewise for tail. However,
123 * it is permissible for head and tail to be referring to deleted
155 * head or tail.
174 * the nodes pointed at by head/tail never get gc-unlinked, since
175 * head/tail are needed to get "back on track" by other nodes that
198 * restart traversal from tail.
232 * - head may not be reachable from the first or last node, or from tail
240 * - the last node is always O(1) reachable from tail vi
248 private transient volatile Node<E> tail; field in class:ConcurrentLinkedDeque
[all...]
H A DLinkedTransferQueue.java29 * producer. The <em>tail</em> of the queue is that element that has
85 * (unmatched) queue node (or null if empty); and "tail" that
90 * head tail
97 * tail pointers. This has led to the development of
133 * updates on head/tail fields.
136 * never versus always updating queue (head and tail) pointers.
143 * head tail
150 * similarly for "tail") is an empirical matter. We have found
157 * virtue of only sometimes updating head or tail pointers when
182 * known first unmatched node, and similarly for tail
534 private transient volatile Node tail; field in class:LinkedTransferQueue
[all...]
/libcore/luni/src/main/java/java/util/concurrent/locks/
H A DAbstractQueuedLongSynchronizer.java63 private transient volatile Node tail; field in class:AbstractQueuedLongSynchronizer
121 Node oldTail = tail;
144 Node oldTail = tail;
188 * traverse backwards from tail to find the actual
194 for (Node p = tail; p != node && p != null; p = p.prev)
221 if (h != null && h != tail) {
301 // If we are the tail, remove ourselves.
302 if (node == tail && compareAndSetTail(node, pred)) {
891 return head != tail;
920 return (head == tail)
[all...]
H A DAbstractQueuedSynchronizer.java292 * tail. To dequeue, you just set the head field.
295 * head | | <---- | | <---- | | tail
300 * operation on "tail", so there is a simple atomic point of
321 * updated "tail" when a node's successor appears to be null.
336 * is constructed and head and tail pointers are set upon first
427 * to be null, we can scan prev's from the tail to
532 private transient volatile Node tail; field in class:AbstractQueuedSynchronizer
588 Node oldTail = tail;
611 Node oldTail = tail;
655 * traverse backwards from tail t
[all...]
/libcore/luni/src/test/java/libcore/java/util/
H A DOldTreeMapTest.java454 Map tail = tm.tailMap(objArray[900].toString());
455 assertTrue("Returned map of incorrect size : " + tail.size(), tail
458 assertTrue("Map contains incorrect entries", tail
486 assertTrue(tail instanceof Serializable);
/libcore/support/src/test/java/tests/resources/x509/
H A Dcreate.sh31 SIG_OFFSET=$(openssl asn1parse -in "$DIR/cert-rsa.der" -inform d | tail -1 | cut -f1 -d:)
103 SIG_OFFSET=$(openssl asn1parse -in "$DIR/crl-rsa.der" -inform d | tail -1 | cut -f1 -d:)
/libcore/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/
H A DControlTest.java378 String tail = src.getFile().split("hyts_resource")[1];
383 String copyName = tmpdir + File.separator + "hyts_resource_copy" + tail;
H A DTreeMapTest.java618 Map tail = tm.tailMap(objArray[900].toString());
619 assertTrue("Returned map of incorrect size : " + tail.size(), tail
622 assertTrue("Map contains incorrect entries", tail
627 assertTrue(tail instanceof Serializable);
1709 // tail map of tail map

Completed in 1429 milliseconds