public void prependPath(Reference r) { if (_path == null) { _path = new LinkedList<Reference>(); } /* Also: let's not increase without bounds. Could choose either * head or tail; tail is easier (no need to ever remove), as * well as potentially more useful so let's use it: */ if (_path.size() < MAX_REFS_TO_LIST) { _path.addFirst(r); } }
String operator = null; for (Iterator<Identifiable> it = input.descendingIterator(); it.hasNext();) { Identifiable identifiable = it.next(); if (operator == null) { rhs.addFirst(identifiable); rhs.removeFirst(); } else { lhs.addFirst(identifiable); return Operators.getOperator(input.get(0).getPosition(), operator, lhsInvokable, rhsInvokable); } catch (NoSuchMethodException e) { final Token operatorToken = (Token) input.get(lhs.size()); throw new ParserException(operatorToken.getPosition(), "Couldn't find operator '" + operator + "'");
wordLinkedList.addFirst(new Word(Predefine.TAG_BIGIN, "S")); wordLinkedList.addLast(new Word(Predefine.TAG_END, "Z")); if (verbose) System.out.println("添加首尾 " + wordList); IWord pre = iterator.next(); while (iterator.hasNext()) IWord current = iterator.next(); if (current.getLabel().startsWith("nt") && !pre.getLabel().startsWith("nt")) pre = iterator.next(); while (iterator.hasNext()) IWord current = iterator.next(); IWord first = iterator.next(); IWord second = iterator.next(); while (iterator.hasNext()) IWord third = iterator.next();
boolean addedBe = false; boolean addedSuffix = false; if (body.size() > 1 && !"PRP".equals(body.get(0).tag())) { for (int i = 2; i < body.size(); ++i) { CoreLabel tokI = body.get(i); if (tokI.tag() != null && i += 1; body.add(i, suffix.get(0)); addedSuffix = true; body.add(prepNum.get(0)); body.add(WORD_IN); body.add(prepNum.get(1)); be.forEach(body::addFirst); body.addFirst(WORD_MISSING); Iterator<CoreLabel> beIter = be.iterator(); if (beIter.hasNext() && body.getLast() == beIter.next()) { body.removeLast();
if (!locs.isEmpty()) { if (cand.serializable()) { Iterator<GridCacheMvccCandidate> it = locs.descendingIterator(); while (it.hasNext()) { GridCacheMvccCandidate c = it.next(); while (it.hasNext()) { GridCacheMvccCandidate c = it.next(); cand.setReentry(); locs.addFirst(cand); for (ListIterator<GridCacheMvccCandidate> it = locs.listIterator(locs.size()); it.hasPrevious(); ) { GridCacheMvccCandidate c = it.previous(); locs.addFirst(cand); locs.add(cand); rmts.add(cand);
while (sbit.hasNext()) { IterableSet body = sbit.next(); IterableSet children = SETParent.get_Body2ChildChain().get(body); worklist.add(SETBasicBlock.get_SETBasicBlock(startSETNode)); find_entry_loop: while (bit.hasNext()) { AugmentedStmt as = (AugmentedStmt) bit.next(); while (pbit.hasNext()) { if (body.contains(pbit.next()) == false) { startSETNode = as.myNode; break find_entry_loop; worklist.add(SETBasicBlock.get_SETBasicBlock(startSETNode)); worklist.add(SETBasicBlock.get_SETBasicBlock(child)); while (worklist.isEmpty() == false) { SETBasicBlock sbb = (SETBasicBlock) worklist.removeFirst(); while (sit.hasNext()) { worklist.addFirst(sit.next());
Set<Object> visited = new HashSet<>(); LinkedList<Object> stack = new LinkedList<>(); stack.addFirst(obj); int hash = 0; while (!stack.isEmpty()) { obj = stack.removeFirst(); if (obj == null || visited.contains(obj)) { continue; int len = Array.getLength(obj); for (int i = 0; i < len; i++) { stack.addFirst(Array.get(obj, i)); stack.add(Math.round(((Number) obj).doubleValue())); continue; stack.addFirst(COMPARISON.getSimpleValue(field.getName(), obj));
protected void flattenTree() { flattenedList = new LinkedList<ExecutionTreeNode>(); LinkedList<ExecutionTreeNode> nodesToHandle = new LinkedList<ExecutionTreeNode>(); nodesToHandle.add(rootNode); while (!nodesToHandle.isEmpty()) { ExecutionTreeNode currentNode = nodesToHandle.pop(); if (reverseOrder) { flattenedList.addFirst(currentNode); } else { flattenedList.add(currentNode); } if (currentNode.getChildren() != null && currentNode.getChildren().size() > 0) { for (ExecutionTreeNode childNode : currentNode.getChildren()) { nodesToHandle.add(childNode); } } } flattenedListIterator = flattenedList.iterator(); }
private static synchronized void addFieldGetter(FieldGetter fieldGetter, Integer index, boolean addLast) { checkParameter(fieldGetter); LinkedList<FieldGetter> ret = getCurrentFieldGetters(); if (index != null) { ret.add(index, fieldGetter); } else { if (addLast) { ret.addLast(fieldGetter); } else { ret.addFirst(fieldGetter); } } getters = ret.toArray(new FieldGetter[ret.size()]); }
void putBackMessage(Message msg) { if( receiveFutures.isEmpty() ) { receivedFrames.addFirst(msg); } else { receiveFutures.removeFirst().onSuccess(msg); } }
@Override public void add(Request request) { if(cursor != 0) { // discard everything newer than cursor position for(int i=0; i<cursor; i++) { data.removeFirst(); } } // Add: data.addFirst(request); // Verify if threshold reached: if(data.size() > maxSize) { data.removeLast(); } // reset cursor: cursor = 0; }
queue.addLast(o); while (! queue.isEmpty()) { for (T obj : getPredecessors(queue.removeFirst())) { if (! visited.contains(obj)) { visited.add(obj); queue.addLast(obj); result.addFirst(obj);
for(int x = loopCount; x > 0; x--) { ll.addFirst(o1); ll.addLast(o2); ll.removeFirst(); ll.removeLast(); ll.add(o1); ll.remove(0); ll.addFirst(o1); ll.addLast(o2); ll.removeFirst(); ll.removeLast(); ll.add(o1); ll.remove(0); ll.addFirst(o1); ll.addLast(o2); ll.removeFirst(); ll.removeLast(); ll.add(o1); ll.remove(0);
@Override public List<OutboundSecurityProvider> selectOutboundProviders() { LinkedList<OutboundSecurityProvider> result = new LinkedList<>(); // only add the ones we are not composing allOutbound.stream() .filter(np -> !configuredOutbound.contains(np.getName())) .forEach(np -> result.add(np.getProvider())); if (null != outbound) { if (isDefault) { result.addFirst(outbound); } else { result.addLast(outbound); } } return result; }