@Override public E peekFirst() { synchronized (mutex) { return delegate().peekFirst(); } }
@Override public E peekFirst() { synchronized (mutex) { return delegate().peekFirst(); } }
@Override public E peekFirst() { return delegate().peekFirst(); }
@Override public void putHead(K key, V value) { buckets.peekFirst().put(key, value); }
public void pushBrace(Brace b) { braceStack.push(b); topBrace = braceStack.peekFirst(); //System.out.println("> " + topBrace); }
public void popBrace() { braceStack.pop(); topBrace = braceStack.peekFirst(); //System.out.println("> " + topBrace); }
/** * Can we send more requests to this node? * * @param node Node in question * @return true iff we have no requests still being sent to the given node */ public boolean canSendMore(String node) { Deque<NetworkClient.InFlightRequest> queue = requests.get(node); return queue == null || queue.isEmpty() || (queue.peekFirst().send.completed() && queue.size() < this.maxInFlightRequestsPerConnection); }
/** * Get the last request we sent to the given node (but don't remove it from the queue) * @param node The node id */ public NetworkClient.InFlightRequest lastSent(String node) { return requestQueue(node).peekFirst(); }
@Override public E peekFirst() { synchronized (mutex) { return delegate().peekFirst(); } }
public static <V> V peekFirst(Deque<V> queue) { if (queue instanceof BTraceDeque || queue.getClass().getClassLoader() == null) { return queue.peekFirst(); } else { throw new IllegalArgumentException(); } }
@Override public E peekFirst() { return delegate().peekFirst(); }
/** * Return buffers to the pool. If they are of the poolable size add them to the free list, otherwise just mark the * memory as free. * * @param buffer The buffer to return * @param size The size of the buffer to mark as deallocated, note that this may be smaller than buffer.capacity * since the buffer may re-allocate itself during in-place compression */ public void deallocate(ByteBuffer buffer, int size) { lock.lock(); try { if (size == this.poolableSize && size == buffer.capacity()) { buffer.clear(); this.free.add(buffer); } else { this.nonPooledAvailableMemory += size; } Condition moreMem = this.waiters.peekFirst(); if (moreMem != null) moreMem.signal(); } finally { lock.unlock(); } }
@Override public E peekFirst() { return delegate().peekFirst(); }
@Override public E peekFirst() { assertTrue(Thread.holdsLock(mutex)); return delegate.peekFirst(); }
/** * Allocate a buffer. If buffer allocation fails (e.g. because of OOM) then return the size count back to * available memory and signal the next waiter if it exists. */ private ByteBuffer safeAllocateByteBuffer(int size) { boolean error = true; try { ByteBuffer buffer = allocateByteBuffer(size); error = false; return buffer; } finally { if (error) { this.lock.lock(); try { this.nonPooledAvailableMemory += size; if (!this.waiters.isEmpty()) this.waiters.peekFirst().signal(); } finally { this.lock.unlock(); } } } }
@Override public E peekFirst() { synchronized (mutex) { return delegate().peekFirst(); } }
private void awaitPendingPartsUpload() throws IOException { checkState(currentUploadInfo.getRemainingParts() == uploadsInProgress.size()); while (currentUploadInfo.getRemainingParts() > 0) { CompletableFuture<PartETag> next = uploadsInProgress.peekFirst(); PartETag nextPart = awaitPendingPartUploadToComplete(next); currentUploadInfo.registerCompletePart(nextPart); uploadsInProgress.removeFirst(); } }
private void checkDeque(Deque<? extends E> deque, DescriptionBuilder builder) { builder.expectThat("empty deque", deque.peekFirst(), is(nullValue())); builder.expectThat("empty deque", deque.peekLast(), is(nullValue())); builder.expectThat("empty deque", deque.descendingIterator().hasNext(), is(false)); }
/** * @return details about one synchronization conflict. */ public IdentityConflict getNextConflict() { IdentityBundle entry = conflictingRemoteIdentities.peekFirst(); return new IdentityConflict(entry.getServer(), securityConfig.getIdentity(entry.getServer()), entry.getClient()); }
create().getFirst(); create().getLast(); create().peekFirst(); create().peekLast(); create().removeFirstOccurrence("e");