public void pop() { wrapped = wrappedStack.pop(); }
public void pop() { wrapped = wrappedStack.pop(); }
@Nullable private T pollObject() { final ReentrantLock lock = this.lock; lock.lock(); try { return objects.isEmpty() ? null : objects.pop(); } finally { lock.unlock(); } }
private T takeObject() throws InterruptedException { final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { while (objects.isEmpty()) { notEnough.await(); } return objects.pop(); } finally { lock.unlock(); } }
/** * @return TreeNode next. The next element according to our in-order traversal of the given BST * @throws NoSuchElementException if this iterator does not have a next element */ @Override public TreeNode<T> next() throws NoSuchElementException { if (pathStack.isEmpty()) { throw new NoSuchElementException(); } TreeNode<T> next = pathStack.pop(); pushPathToNextSmallest(next.getRight()); return next; }
public String popNdc() { ArrayDeque<Entry> stack = ndcStack.get(); return stack == null || stack.isEmpty() ? "" : stack.pop().current; }
public void setNdcMaxDepth(int maxDepth) { final ArrayDeque<Entry> stack = ndcStack.get(); if (stack != null) while (stack.size() > maxDepth) stack.pop(); }
private List<T> takeObjects(int elementNum) throws InterruptedException { final List<T> list = new ArrayList<>(elementNum); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { while (objects.size() < elementNum) { notEnough.await(); } for (int i = 0; i < elementNum; i++) { list.add(objects.pop()); } return list; } finally { lock.unlock(); } }
private List<T> pollObjects(int elementNum) throws InterruptedException { final List<T> list = new ArrayList<>(elementNum); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { if (objects.size() < elementNum) { return Collections.emptyList(); } else { for (int i = 0; i < elementNum; i++) { list.add(objects.pop()); } return list; } } finally { lock.unlock(); } }
@Nullable private T pollObject(long timeoutMs) throws InterruptedException { long nanos = TIME_UNIT.toNanos(timeoutMs); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { while (objects.isEmpty()) { if (nanos <= 0) { return null; } nanos = notEnough.awaitNanos(nanos); } return objects.pop(); } finally { lock.unlock(); } }
private List<T> pollObjects(int elementNum, long timeoutMs) throws InterruptedException { long nanos = TIME_UNIT.toNanos(timeoutMs); final List<T> list = new ArrayList<>(elementNum); final ReentrantLock lock = this.lock; lock.lockInterruptibly(); try { while (objects.size() < elementNum) { if (nanos <= 0) { return Collections.emptyList(); } nanos = notEnough.awaitNanos(nanos); } for (int i = 0; i < elementNum; i++) { list.add(objects.pop()); } return list; } finally { lock.unlock(); } }
public void distributeEvents() { //add collision callbacks int clistsize = collisionListeners.size(); while( collisionEvents.isEmpty() == false ) { PhysicsCollisionEvent physicsCollisionEvent = collisionEvents.pop(); for(int i=0;i<clistsize;i++) { collisionListeners.get(i).collision(physicsCollisionEvent); } //recycle events eventFactory.recycle(physicsCollisionEvent); } }
/** * Distribute each collision event to all listeners. */ public void distributeEvents() { //add collision callbacks int clistsize = collisionListeners.size(); while( collisionEvents.isEmpty() == false ) { PhysicsCollisionEvent physicsCollisionEvent = collisionEvents.pop(); for(int i=0;i<clistsize;i++) { collisionListeners.get(i).collision(physicsCollisionEvent); } //recycle events eventFactory.recycle(physicsCollisionEvent); } }
private void processAtomEnded(long atomEndPosition) throws ParserException { while (!containerAtoms.isEmpty() && containerAtoms.peek().endPosition == atomEndPosition) { onContainerAtomRead(containerAtoms.pop()); } enterReadingAtomHeaderState(); }
private static void findUnannotatedTypeVarRefs( TypeVariableSymbol typeVar, Tree sourceNode, Type type, ArrayDeque<Integer> partialSelector, ImmutableSet.Builder<InferenceVariable> resultBuilder) { List<Type> typeArguments = type.getTypeArguments(); for (int i = 0; i < typeArguments.size(); i++) { partialSelector.push(i); findUnannotatedTypeVarRefs( typeVar, sourceNode, typeArguments.get(i), partialSelector, resultBuilder); partialSelector.pop(); } if (type.tsym.equals(typeVar) && !toNullness(type.getAnnotationMirrors()).isPresent()) { resultBuilder.add( TypeArgInferenceVar.create(ImmutableList.copyOf(partialSelector), sourceNode)); } }
@Override void handleClose() { if (pendingPushes.remove(this)) { completionHandler.fail("Push reset by client"); } else { concurrentStreams--; while ((maxConcurrentStreams == null || concurrentStreams < maxConcurrentStreams) && pendingPushes.size() > 0) { Push push = pendingPushes.pop(); concurrentStreams++; context.runOnContext(v -> { push.complete(); }); } response.handleClose(); } }
@Override public void exitMessageRef(RuleLangParser.MessageRefContext ctx) { isIdIsFieldAccess.pop(); // reset for error checks final Expression fieldExpr = exprs.get(ctx.field); final MessageRefExpression expr = new MessageRefExpression(ctx.getStart(), fieldExpr); log.trace("$MSG: ctx {} => {}", ctx, expr); exprs.put(ctx, expr); }
private void generateConstraintsFromAnnotations( Type type, Tree sourceTree, ArrayDeque<Integer> argSelector) { List<Type> typeArguments = type.getTypeArguments(); int numberOfTypeArgs = typeArguments.size(); for (int i = 0; i < numberOfTypeArgs; i++) { argSelector.push(i); generateConstraintsFromAnnotations(typeArguments.get(i), sourceTree, argSelector); argSelector.pop(); } // Use equality constraints even for top-level type, since we want to "trust" the annotation // TODO(b/121398981): skip for T extends @<Annot> since they constrain one side only ProperInferenceVar.fromTypeIfAnnotated(type) .ifPresent( annot -> { qualifierConstraints.putEdge( TypeArgInferenceVar.create(ImmutableList.copyOf(argSelector), sourceTree), annot); qualifierConstraints.putEdge( annot, TypeArgInferenceVar.create(ImmutableList.copyOf(argSelector), sourceTree)); }); }
@Override public void exitNested(RuleLangParser.NestedContext ctx) { isIdIsFieldAccess.pop(); // reset for error checks final Expression object = exprs.get(ctx.fieldSet); final Expression field = exprs.get(ctx.field); final FieldAccessExpression expr = new FieldAccessExpression(ctx.getStart(), object, field); log.trace("FIELDACCESS: ctx {} => {}", ctx, expr); exprs.put(ctx, expr); }
private void processAtomEnded(long atomEndPosition) throws ParserException { while (!containerAtoms.isEmpty() && containerAtoms.peek().endPosition == atomEndPosition) { Atom.ContainerAtom containerAtom = containerAtoms.pop(); if (containerAtom.type == Atom.TYPE_moov) { // We've reached the end of the moov atom. Process it and prepare to read samples. processMoovAtom(containerAtom); containerAtoms.clear(); parserState = STATE_READING_SAMPLE; } else if (!containerAtoms.isEmpty()) { containerAtoms.peek().add(containerAtom); } } if (parserState != STATE_READING_SAMPLE) { enterReadingAtomHeaderState(); } }