How to use

Deque

in

java.util

 @Override public List<Cookie> loadForRequest(HttpUrl url) {
  if (requestCookies.isEmpty()) return Collections.emptyList();
  return requestCookies.removeFirst();
 }
}

public void pushActiveContextObject(TypedValue obj) {
  if (this.contextObjects == null) {
    this.contextObjects = new ArrayDeque<>();
  }
  this.contextObjects.push(obj);
}

/**
 * Exit a compilation scope, usually after a nested expression has been evaluated. For
 * example after an argument for a method invocation has been evaluated this method
 * returns us to the previous (outer) scope.
 */
public void exitCompilationScope() {
  this.compilationScopes.pop();
}

/**
 * Undo last spell
 */
public void undoLastSpell() {
 if (!undoStack.isEmpty()) {
  Command previousSpell = undoStack.pollLast();
  redoStack.offerLast(previousSpell);
  LOGGER.info("{} undoes {}", this, previousSpell);
  previousSpell.undo();
 }
}

private void store(Level level, String msg) {
  buffer.addLast(new LogEvent(level, msg));
  if (buffer.size() > BUFFER_SIZE) {
    buffer.pollFirst();
  }
}

public void testHoldsLockOnAllOperations() {
 create().element();
 create().offer("foo");
 create().peek();
 create().poll();
 create().remove();
 create().add("foo");
 create().addAll(ImmutableList.of("foo"));
 create().clear();
 create().contains("foo");
 create().containsAll(ImmutableList.of("foo"));
 create().equals(new ArrayDeque<>(ImmutableList.of("foo")));
 create().hashCode();
 create().isEmpty();
 create().iterator();
 create().remove("foo");
 create().removeAll(ImmutableList.of("foo"));
 create().retainAll(ImmutableList.of("foo"));
 create().size();
 create().toArray();
 create().toArray(new String[] {"foo"});
 create().addFirst("e");
 create().addLast("e");
 create().offerFirst("e");
 create().offerLast("e");
 create().removeFirst();
 create().removeLast();
 create().pollFirst();
 create().pollLast();
 create().getFirst();

@Override
public boolean hasNext()
{
  if (geometriesDeque.isEmpty()) {
    return false;
  }
  while (geometriesDeque.peek() instanceof OGCConcreteGeometryCollection) {
    OGCGeometryCollection collection = (OGCGeometryCollection) geometriesDeque.pop();
    for (int i = 0; i < collection.numGeometries(); i++) {
      geometriesDeque.push(collection.geometryN(i));
    }
  }
  return !geometriesDeque.isEmpty();
}

private void writeValue( Object value )
{
  assert !stack.isEmpty();
  Writer head = stack.peek();
  head.write( value );
}

/**
 * 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);
}

public String getFullName() {
  if (cachedPackageFullName == null) {
    Deque<PackageNode> pp = getParentPackages();
    StringBuilder result = new StringBuilder();
    result.append(pp.pop().getName());
    while (!pp.isEmpty()) {
      result.append(SEPARATOR_CHAR);
      result.append(pp.pop().getName());
    }
    cachedPackageFullName = result.toString();
  }
  return cachedPackageFullName;
}

/**
 * An analogue of {@link java.util.function.DoubleFunction} also accepting an index.
 *
 * <p>This interface is only intended for use by callers of {@link #mapWithIndex(DoubleStream,
 * DoubleFunctionWithIndex)}.
 *
 * @since 21.0
 */
@Beta
public interface DoubleFunctionWithIndex<R> {
 /** Applies this function to the given argument and its index within a stream. */
 R apply(double from, long index);
}

/** Used by {@code Call#execute} to signal it is in-flight. */
synchronized void executed(RealCall call) {
 runningSyncCalls.add(call);
}

public void push(IRegion region) {
  stack.push(curState);
  if (stack.size() > REGIONS_STACK_LIMIT) {
    throw new JadxOverflowException("Regions stack size limit reached");
  }
  curState = curState.copy();
  curState.region = region;
  if (DEBUG) {
    LOG.debug("Stack push: {}: {}", size(), curState);
  }
}

/**
 * Return the current number of statements or statement parameters
 * in the queue.
 */
public int getQueueCount() {
  return this.parameterQueue.size();
}

private boolean inTag() {
  return !this.tagState.isEmpty();
}

/**
 * Attempt to ensure we have at least the requested number of bytes of memory for allocation by deallocating pooled
 * buffers (if needed)
 */
private void freeUp(int size) {
  while (!this.free.isEmpty() && this.nonPooledAvailableMemory < size)
    this.nonPooledAvailableMemory += this.free.pollLast().capacity();
}

@Override
public void visitToken(DetailAST ast) {
  final AbstractExpressionHandler handler = handlerFactory.getHandler(this, ast,
    handlers.peek());
  handlers.push(handler);
  handler.checkIndentation();
}

synchronized void enqueue(AsyncCall call) {
 if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
  runningAsyncCalls.add(call);
  executorService().execute(call);
 } else {
  readyAsyncCalls.add(call);
 }
}

@Override
public void addFirst(E e) {
 synchronized (mutex) {
  delegate().addFirst(e);
 }
}

@Nullable
public CompositeComponentDefinition getContainingComponent() {
  return this.containingComponents.peek();
}