/** * Retrieves and removes an extracted message from the accumulated buffer * or returns null if there are no more messages. */ public Message getMessage() { if( messages.isEmpty() ) { return null; } return messages.removeFirst(); }
/** * maintains a list of last <i>committedLog</i> * or so committed requests. This is used for * fast follower synchronization. * @param request committed request */ public void addCommittedProposal(Request request) { WriteLock wl = logLock.writeLock(); try { wl.lock(); if (committedLog.size() > commitLogCount) { committedLog.removeFirst(); minCommittedLog = committedLog.getFirst().packet.getZxid(); } if (committedLog.isEmpty()) { minCommittedLog = request.zxid; maxCommittedLog = request.zxid; } byte[] data = SerializeUtils.serializeRequest(request); QuorumPacket pp = new QuorumPacket(Leader.PROPOSAL, request.zxid, data, null); Proposal p = new Proposal(); p.packet = pp; p.request = request; committedLog.add(p); maxCommittedLog = p.packet.getZxid(); } finally { wl.unlock(); } }
private void buildIndex() { LinkedList<TreeNode> queue = new LinkedList<>(); queue.add(root); while (!queue.isEmpty()) { TreeNode node = queue.removeFirst(); index.put(node.cuboidId, node); for (TreeNode child : node.children) { queue.add(child); } } }
private static boolean insertNestedClass(ClassNode root, ClassNode child) { Set<String> setEnclosing = child.enclosingClasses; LinkedList<ClassNode> stack = new LinkedList<>(); stack.add(root); while (!stack.isEmpty()) { ClassNode node = stack.removeFirst(); if (setEnclosing.contains(node.classStruct.qualifiedName)) { node.nested.add(child); child.parent = node; return true; } // note: ordered list stack.addAll(node.nested); } return false; }
while (!preTerms.isEmpty() && isPunc(preTerms.getFirst())) { newChildren.add(preTerms.getFirst()); preTerms.removeFirst(); newChildren.add(newChild); while (!preTerms.isEmpty() && isPunc(preTerms.getLast())) { temp.addFirst(preTerms.getLast()); preTerms.removeLast(); while (!newChildren.isEmpty() && isPunc(newChildren.getFirst())) { newChildren.removeFirst(); while (!newChildren.isEmpty() && isPunc(newChildren.getLast())) { newChildren.removeLast();
public boolean hasMoreData() { while (!sources.isEmpty() && !((DoubleDataSource) sources.getFirst()).hasMoreData()) { sources.removeFirst(); } if (sources.isEmpty()) return false; return true; }
private static List<Configurations> collate( List<Configurations> orderedConfigurations) { LinkedList<Configurations> collated = new LinkedList<>(); for (Configurations item : orderedConfigurations) { if (collated.isEmpty() || collated.getLast().getClass() != item.getClass()) { collated.add(item); } else { collated.set(collated.size() - 1, collated.getLast().merge(item)); } } return collated; }
Integer old = index; if (index == null) { index = history.size() - 1; } else { if (up) { index = index - 1; if (index < 0) { index = history.size() - 1; if (index > history.size() - 1) { index = 0; channel.setAttribute(HISTORY_LIST_KEY, history); if (history.isEmpty()) { history.addLast(result); } else if (!result.equals(history.getLast())) { history.remove(result); history.addLast(result); if (history.size() > 10) { history.removeFirst();
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(); }
public Builder edge(final Edge edge) { if (entities.isEmpty()) { entities.add(new AbstractMap.SimpleEntry<>(edge.getMatchedVertexValue(), Sets.newHashSet())); } else { verifyEdge(entities.getLast().getKey(), edge); } edges.add(Sets.newHashSet(edge)); entities.add(new AbstractMap.SimpleEntry<>(edge.getAdjacentMatchedVertexValue(), Sets.newHashSet())); return this; }
public void addErrors(List<CounterError> counterErrorList) { assert errorCounter; if (counterErrorList.isEmpty()) { return; } synchronized (errors) { if (!errors.isEmpty() && errors.get(0).getTime() > counterErrorList.get(0).getTime()) { // tant que faire se peut on les met à peu près dans l'ordre pour le sort ci après errors.addAll(0, counterErrorList); } else { errors.addAll(counterErrorList); } if (errors.size() > 1) { // "sort" a les mêmes performances sur LinkedList que sur ArrayList car il y a un tableau intermédiaire // (selon Implementation Patterns, Kent Beck) Collections.sort(errors, new CounterErrorComparator()); while (errors.size() > MAX_ERRORS_COUNT) { errors.removeFirst(); } } } }
private void cleanUpHistory() { if (!mHistoryOfNumbers.isEmpty() && mHistoryOfNumbers.size() >= MAX_HISTORY_SIZE) { for (int i = 0; i < Math.max(1, MAX_HISTORY_SIZE / 2); i++) { mPreviousNumbers.remove(mHistoryOfNumbers.removeFirst()); } } } }
/** * Creates a MessageAck for all messages contained in deliveredMessages. * Caller should hold the lock for deliveredMessages. * * @param type Ack-Type (i.e. MessageAck.STANDARD_ACK_TYPE) * @return <code>null</code> if nothing to ack. */ private MessageAck makeAckForAllDeliveredMessages(byte type) { synchronized (deliveredMessages) { if (deliveredMessages.isEmpty()) { return null; } MessageDispatch md = deliveredMessages.getFirst(); MessageAck ack = new MessageAck(md, type, deliveredMessages.size()); ack.setFirstMessageId(deliveredMessages.getLast().getMessage().getMessageId()); return ack; } }
while (!stack.isEmpty()) { Group g = stack.getFirst(); stack.removeFirst();
@Override public void run() { main: while (!siblingList.isEmpty()) { final Pair<PsiBuilder.Marker, PsiBuilder.Marker> parenPair = parenList.peek(); final int rating = siblingList.getFirst().second; int count = 0; for (Pair<PsiBuilder.Marker, Integer> pair : siblingList) { if (pair.second != rating || parenPair != null && pair.first == parenPair.second) break main; if (++count >= MAX_CHILDREN_IN_TREE) { PsiBuilder.Marker parentMarker = pair.first.precede(); parentMarker.setCustomEdgeTokenBinders(WhitespacesBinders.GREEDY_LEFT_BINDER, null); while (count-- > 0) { siblingList.removeFirst(); } parentMarker.done(chunkType); siblingList.addFirst(Pair.create(parentMarker, rating + 1)); continue main; } } break; } } };