private boolean startProcessing() { LOG.assertTrue(Thread.holdsLock(myQueue)); if (isProcessing || !myStarted) { return false; } isProcessing = true; final T item = myQueue.removeFirst(); final Runnable runnable = () -> { if (myDeathCondition.value(null)) return; runSafely(() -> myProcessor.consume(item, myContinuationContext)); }; final Application application = ApplicationManager.getApplication(); if (myThreadToUse == ThreadToUse.AWT) { final ModalityState state = myModalityState.remove(new MyOverrideEquals(item)); if (state != null) { application.invokeLater(runnable, state); } else { application.invokeLater(runnable); } } else { application.executeOnPooledThread(runnable); } return true; }
/** * Uses the extraction template generated by the {@link #templateGeneration} process and utilizes * some own characteristics of the target page pt to extract the content of it which first needs * to be parsed to a DOM tree <em>tp</em>. * * @param tt The previouslz generated extraction template * @param tp_i The root DOM element of the document to predict the main content for */ public void newsContentExtraction(Deque<Token> tt, Token tp_i) { // templateNode <-- tt.firstElement Token templateNode = tt.getFirst(); if (templateNode.getName().equals(tp_i.getName()) && templateNode.getLevel() == tp_i.getLevel() && templateNode.getSibNo() == tp_i.getSibNo()) { tt.removeFirst(); if (tt.size() > 0) { Token nextTemplateNode = tt.getFirst(); if (tp_i.getChildren() == null || tp_i.getChildren().length == 0) { LOG.info(tp_i.getText()); while (nextTemplateNode.getParentNo() == templateNode.getNo()) { tt.removeFirst(); templateNode = nextTemplateNode; nextTemplateNode = tt.getFirst(); } } else { if (nextTemplateNode.getParentNo() != templateNode.getNo()) { System.out.println(this.deleteEmbeddedNoise(tp_i.getSubtreeText())); } for (int j = 0; j < tp_i.getChildren().length; j++) { this.newsContentExtraction(tt, tp_i.getChildren()[j]); } } } else { LOG.info(this.deleteEmbeddedNoise(tp_i.getSubtreeText())); } } }
public static void main(String[] args) { Random r = new Random(); for (int times = 0; times < 1000; ++times) { int n; if (args.length == 1) { n = Integer.parseInt(args[0]); } else { n = r.nextInt(10000) + 1; } List<Integer> A = new ArrayList<>(); for (int i = 0; i < n; ++i) { Integer height = r.nextInt(2 * n) + 1; A.add(height); } Deque<BuildingWithHeight> res = examineBuildingsWithSunset(A.iterator()); BuildingWithHeight prev = res.removeFirst(); System.out.println(prev); while (!res.isEmpty()) { BuildingWithHeight current = res.removeFirst(); System.out.println(current); assert (prev.id < current.id); assert (prev.height > current.height); prev = current; } } }
/** * Performs a depth-first, post-order traversal over a DAG. * * @param initialNodes The nodes from which to perform the traversal. Not allowed to contain * {@code null}. * @throws CycleException if a cycle is found while performing the traversal. */ @SuppressWarnings("PMD.PrematureDeclaration") public void traverse(Iterable<? extends T> initialNodes) throws CycleException, IOException, InterruptedException { // This corresponds to the current chain of nodes being explored. Enforcing this invariant makes // this data structure useful for debugging. Deque<Explorable> toExplore = Lists.newLinkedList(); for (T node : initialNodes) { toExplore.add(new Explorable(node)); } Set<T> inProgress = Sets.newHashSet(); LinkedHashSet<T> explored = Sets.newLinkedHashSet(); while (!toExplore.isEmpty()) { Explorable explorable = toExplore.peek(); T node = explorable.node; // This could happen if one of the initial nodes is a dependency of the other, for example. if (explored.contains(node)) { toExplore.removeFirst(); continue; } inProgress.add(node); // Find children that need to be explored to add to the stack. int stackSize = toExplore.size(); for (Iterator<T> iter = explorable.children; iter.hasNext(); ) { T child = iter.next(); if (inProgress.contains(child)) { throw createCycleException(child, toExplore); } else if (!explored.contains(child)) { toExplore.addFirst(new Explorable(child)); // Without this break statement: // (1) Children will be explored in reverse order instead of the specified order. // (2) CycleException may contain extra nodes. // Comment out the break statement and run the unit test to verify this for yourself. break; } } if (stackSize == toExplore.size()) { // Nothing was added to toExplore, so the current node can be popped off the stack and // marked as explored. toExplore.removeFirst(); inProgress.remove(node); explored.add(node); // Now that the internal state of this traversal has been updated, notify the observer. onNodeExplored(node); } } Preconditions.checkState(inProgress.isEmpty(), "No more nodes should be in progress."); onTraversalComplete(Iterables.unmodifiableIterable(explored)); }
void playPrevious() { if (playStack.size() < 2) return; System.out.println("------------"); for (PlaylistAndTrack pnt : playStack) { System.out.println(pnt.track.getTitle()); } playStack.removeFirst(); PlaylistAndTrack prevPlaylistAndTrack = playStack.removeFirst(); playlistsView.getSelectionModel().select(prevPlaylistAndTrack.playlist); tracksView.getSelectionModel().select(prevPlaylistAndTrack.track); tracksView.scrollTo(tracksView.getSelectionModel().getSelectedIndex()); playTrack(prevPlaylistAndTrack.track); }
public Future<SessionMessage> requestMessage( Map<String, InputOperation> operations, ExecutionThread ethread) { final SessionMessageFuture future = new SessionMessageNDFuture(operations.keySet().toArray(new String[0])); ethread.cancelIfKilled(future); synchronized (messageQueues) { Deque<SessionMessage> queue = null; SessionMessage message = null; InputOperation operation = null; Iterator<Deque<SessionMessage>> it = messageQueues.values().iterator(); while (operation == null && it.hasNext()) { queue = it.next(); message = queue.peekFirst(); if (message != null) { operation = operations.get(message.message().operationName()); } } if (message == null) { queue = uncorrelatedMessageQueue; message = queue.peekFirst(); if (message != null) { operation = operations.get(message.message().operationName()); } } if (message == null || operation == null) { for (Map.Entry<String, InputOperation> entry : operations.entrySet()) { addMessageWaiter(entry.getValue(), future); } } else { future.setResult(message); queue.removeFirst(); // Check if we unlocked other receives boolean keepRun = true; SessionMessageFuture f; while (keepRun && !queue.isEmpty()) { message = queue.peekFirst(); f = getMessageWaiter(message.message().operationName()); if (f != null) { // We found a waiter for the unlocked message f.setResult(message); queue.removeFirst(); } else { keepRun = false; } } } } return future; }
@Test public void Deque_addFirst_removeFirst_AddsRemovesTwo() { deque.addFirst("firstString"); deque.addFirst("secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 2); String returnedString = deque.removeFirst(); assertEquals(returnedString, "secondString"); assertFalse(deque.isEmpty()); assertEquals(deque.size(), 1); returnedString = deque.removeFirst(); assertEquals(returnedString, "firstString"); assertTrue(deque.isEmpty()); assertEquals(deque.size(), 0); }
public T undo() { if (isUndoable()) { future.addFirst(present); present = past.removeFirst(); } return present; }
@Override public Path search(Integer source, Integer target) { check(source, target); Deque<Integer> queue = new ArrayDeque<>(graph.size()); Map<Integer, Integer> parents = new HashMap<>(graph.size()); queue.addLast(source); parents.put(source, null); while (!queue.isEmpty()) { Integer current = queue.removeFirst(); if (current.equals(target)) { return tracebackPath(target, parents, graph); } for (Integer child : graph.getChildrenOf(current)) { if (!parents.containsKey(child)) { parents.put(child, current); queue.addLast(child); } } } return Path.emptyPath(); }
@Override public WebSocketSession getSession(Deque<SessionContext> sessionContexts) { // Remove the first item, and add at the end SessionContext s = sessionContexts.removeFirst(); sessionContexts.addLast(s); return s.getSession(); }
private void cycleKeyList(Object key) { keyList.addLast(key); if (keyList.size() > size) { Object oldestKey = keyList.removeFirst(); delegate.removeObject(oldestKey); } }
/** * @param instanceFrame instance frame * @return iterable over instance members of the frame, including those nested in namespaces */ public static Iterable<? extends INamedElement> instanceMembers( final IInstanceFrame instanceFrame) { final List<INamedElement> members = new ArrayList<>(); // Iterate over the member functions of the frame, including those nested in namespaces. final Deque<INamedElement> queue = new LinkedList<>(); queue.addLast(instanceFrame); while (!queue.isEmpty()) { final INamedElement cur = queue.getFirst(); queue.removeFirst(); final INamedElementContainer contCur = (INamedElementContainer) cur; for (final INamedElement member : contCur.members()) if (Ast.membership(member) == (contCur == instanceFrame ? ScopeMembership.InstanceMember : ScopeMembership.StaticMember)) { members.add(member); if (member instanceof INamedElementContainer) { // Tail-recursively treat this nested namespace. queue.addLast(member); } } } return members; }
public T redo() { if (isRedoable()) { past.addFirst(present); present = future.removeFirst(); } return present; }
/* (non-Javadoc) * @see botFramework.IBot#sendCommands() */ public void sendCommands() { String command; boolean success; while (!queuedCommands.isEmpty()) { command = queuedCommands.removeFirst(); success = send(command); if (success == false) { queuedCommands.addFirst(command); log.error("error sending command. will reconnect and retry"); sendErrorEvent("Bot.sendCommands", "problem", "Could not send - reconnecting"); reconnect("Write error!"); return; } } try { sender.flush(); } catch (SocketTimeoutException e) { log.error("socket timeout while flushing", e); sendErrorEvent("Bot.sendCommands", "SocketTimeoutException", e.getMessage()); } catch (IOException e) { log.error("ioexception while flushing", e); sendErrorEvent("Bot.sendCommands", "IOException", e.getMessage()); reconnect("Write error!"); } }
private void updateEstimates(int secondsRemaining) { // Archivo.logger.debug("Adding {} to estimates", secondsRemaining); recentEndTimeEstimates.addLast(secondsRemaining); if (recentEndTimeEstimates.size() > MAX_END_TIME_ESTIMATES) { recentEndTimeEstimates.removeFirst(); } }
// Method 2: BFS Solution public boolean validTreeII(int n, int[][] edges) { int[] visited = new int[n]; List<List<Integer>> adjList = new ArrayList<>(); for (int i = 0; i < n; ++i) { adjList.add(new ArrayList<Integer>()); } for (int[] edge : edges) { adjList.get(edge[0]).add(edge[1]); adjList.get(edge[1]).add(edge[0]); } Deque<Integer> q = new LinkedList<Integer>(); q.addLast(0); visited[0] = 1; // vertex 0 is in the queue, being visited while (!q.isEmpty()) { Integer cur = q.removeFirst(); for (Integer succ : adjList.get(cur)) { if (visited[succ] == 1) { return false; } // loop detected if (visited[succ] == 0) { q.addLast(succ); visited[succ] = 1; } } visited[cur] = 2; // visit completed } for (int v : visited) { if (v == 0) { return false; } } // # of connected components is not 1 return true; }
public int[] maxSlidingWindow(int[] nums, int k) { if (nums.length == 0 || k == 0) { return new int[] {}; } int[] result = new int[nums.length - k + 1]; PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>( k, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { if (o1 < o2) { return 1; } else if (o1 > o2) { return -1; } else { return 0; } } }); Deque<Integer> deque = new LinkedList<Integer>(); for (int i = 0; i < k; i++) { deque.addLast(nums[i]); priorityQueue.add(nums[i]); } for (int i = k; i < nums.length; i++) { result[i - k] = priorityQueue.peek(); int first = deque.removeFirst(); priorityQueue.remove(first); deque.addLast(nums[i]); priorityQueue.add(nums[i]); } result[result.length - 1] = priorityQueue.peek(); return result; }
/** This method builds an actual tree from multiple path. */ private ARGState buildTreeFromMultiplePaths(final Collection<ARGPath> targetPaths) { ARGState itpTreeRoot = null; Deque<ARGState> todo = new ArrayDeque<>(extractTargets(targetPaths)); // build the tree, bottom-up, starting from the target states while (!todo.isEmpty()) { final ARGState currentState = todo.removeFirst(); if (currentState.getParents().iterator().hasNext()) { if (!predecessorRelation.containsKey(currentState)) { ARGState parentState = currentState.getParents().iterator().next(); predecessorRelation.put(currentState, parentState); successorRelation.put(parentState, currentState); todo.addFirst(parentState); } } else if (itpTreeRoot == null) { itpTreeRoot = currentState; } } return itpTreeRoot; }
/* (non-Javadoc) * @see botFramework.IBot#sendMessages() */ public void sendMessages() { BotMessage msg; boolean success; if (!queuedMessages.isEmpty()) { msg = queuedMessages.removeFirst(); messageTimer.schedule(msg, msg.getDelay()); } }
@Test(expected = NoSuchElementException.class) public void Deque_addLast_removeFirst_throwsIfEmpty() { deque.addFirst("firstString"); deque.addFirst("secondString"); deque.removeLast(); deque.removeLast(); deque.removeFirst(); }
private void prune() { // Remove all values that are too old TimeInterval periodAllowed = cachedPeriod.before(buffer.getLast().getTimestamp()); while (!buffer.isEmpty() && !periodAllowed.contains(buffer.getFirst().getTimestamp())) { // Discard value buffer.removeFirst(); } }
private String upload() throws UploadException, IOException { Uploader uploader = new Uploader(); uploader.setMaxFileSize(MAX_FILE_SIZE); uploader.setName(captchan.tfName.getText()); uploader.setEmail(captchan.tfEmail.getText()); uploader.setSubject(captchan.tfSubject.getText()); uploader.setComment(getComment()); uploader.setChallenge(reChallenges.removeFirst()); uploader.setResponse(reResponses.removeFirst()); uploader.setFile(files[workingOn]); uploader.setPostURL(postURL); uploader.setTopicURL(topicURL); uploader.setThread(captchan.tfThread.getText()); uploader.setUserAgent(userAgent); return uploader.upload(); }
/** * Add a entry to the history list. This causes that the redo list is cleared and in case the undo * list is getting too long the oldest entry is removed. * * @param entry the entry to add to this list */ @SuppressWarnings("nls") public void addEntry(final HistoryAction entry) { undoList.addLast(entry); redoList.clear(); while (undoList.size() > MAX_HISTORY_LENGHT) { undoList.removeFirst(); } }
/** * Get a JdbConnection object either by the ones available in the queue or replace the first * expired connection. When a connection is given to a client, it is tagged with the current time. * This enables us to check the duration it has been out and replace if required. * * @return JDBConnection This contains the actual jdbc connection object to db. * @throws ConnectionPoolException Throws if no available connections */ public synchronized JdbConnection borrow() throws ConnectionPoolException { if (pooled.size() > 0) { borrowed.put(pooled.peek(), Instant.now()); return pooled.removeFirst(); } else { return createReplacementIfExpiredConnFound(); } }
@Override protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception { Subject subject = getSubject(request, response); if (!subject.isAuthenticated() && !subject.isRemembered()) { // 如果没有登录,直接进行之后的流程 return true; } Session session = subject.getSession(); // String username = (String) subject.getPrincipal(); String account = ((ShiroUser) subject.getPrincipal()).getAccount(); Serializable sessionId = session.getId(); // TODO 同步控制 Deque<Serializable> deque = cache.get(account); if (deque == null) { deque = new LinkedList<Serializable>(); cache.put(account, deque); } // 如果队列里没有此sessionId,且用户没有被踢出;放入队列 if (!deque.contains(sessionId) && session.getAttribute("kickout") == null) { deque.push(sessionId); } // 如果队列里的sessionId数超出最大会话数,开始踢人 while (deque.size() > maxSession) { Serializable kickoutSessionId = null; if (kickoutAfter) { // 如果踢出后者 kickoutSessionId = deque.removeFirst(); } else { // 否则踢出前者 kickoutSessionId = deque.removeLast(); } try { Session kickoutSession = sessionManager.getSession(new DefaultSessionKey(kickoutSessionId)); if (kickoutSession != null) { // 设置会话的kickout属性表示踢出了 kickoutSession.setAttribute("kickout", true); } } catch (Exception e) { // ignore exception } } // 如果被踢出了,直接退出,重定向到踢出后的地址 if (session.getAttribute("kickout") != null) { // 会话被踢出了 try { subject.logout(); } catch (Exception e) { // ignore } saveRequest(request); WebUtils.issueRedirect(request, response, kickoutUrl); return false; } return true; }
private void shiftBufferIfLastBinIsStale() { long latest = deque.peekLast().timestamp.getTime(); if (System.currentTimeMillis() - latest > HOUR_IN_MILLIS) { deque.removeFirst(); latest += HOUR_IN_MILLIS; deque.addLast(new HourlyAggregateData(latest)); } }
public static <T extends FlowRenderable<T>> Iterable<LaidFlowLine<T>> getLines( Collection<T> flowRenderables, TextRenderStyle defaultRenderStyle, int yStart, ContainerRenderSpace containerRenderSpace) { // Take into account a minimum width int minWidth = determineMinWidth(flowRenderables, defaultRenderStyle); int x = 0; int y = yStart; int availableWidth = Math.max(minWidth, containerRenderSpace.getWidthForVerticalPosition(y)); List<LaidFlowLine<T>> result = new LinkedList<>(); int maxHeightInLine = 0; Deque<T> renderablesQueue = new LinkedList<>(flowRenderables); List<T> renderablesInLine = new LinkedList<>(); while (!renderablesQueue.isEmpty()) { FlowRenderable<T> flowRenderable = renderablesQueue.removeFirst(); FlowRenderable.SplitResult<T> splitResult = flowRenderable.splitAt(defaultRenderStyle, availableWidth - x); if (splitResult.before == null) { // This is the end of the line, this renderable doesn't fit result.add(new DefaultLaidFlowLine<>(x, maxHeightInLine, renderablesInLine)); renderablesInLine = new LinkedList<>(); x = 0; y += maxHeightInLine; availableWidth = Math.max(minWidth, containerRenderSpace.getWidthForVerticalPosition(y)); maxHeightInLine = 0; renderablesQueue.addFirst(splitResult.rest); } else { // Append the "before" part and push the "rest" onto the Deque if not null int renderableWidth = splitResult.before.getWidth(defaultRenderStyle); int renderableHeight = splitResult.before.getHeight(defaultRenderStyle); x += renderableWidth; maxHeightInLine = Math.max(maxHeightInLine, renderableHeight); renderablesInLine.add(splitResult.before); if (splitResult.rest != null) { result.add(new DefaultLaidFlowLine<>(x, maxHeightInLine, renderablesInLine)); renderablesInLine = new LinkedList<>(); x = 0; y += maxHeightInLine; availableWidth = Math.max(minWidth, containerRenderSpace.getWidthForVerticalPosition(y)); maxHeightInLine = 0; renderablesQueue.addFirst(splitResult.rest); } } } result.add(new DefaultLaidFlowLine<>(x, maxHeightInLine, renderablesInLine)); return result; }
private Schema loadFromDirectories(List<Path> directories) throws IOException { final Deque<String> protos = new ArrayDeque<>(this.protos); if (protos.isEmpty()) { for (final Path directory : directories) { Files.walkFileTree( directory, new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { protos.add(directory.relativize(file).toString()); return FileVisitResult.CONTINUE; } }); } } Map<String, ProtoFile> loaded = new LinkedHashMap<>(); while (!protos.isEmpty()) { String proto = protos.removeFirst(); if (loaded.containsKey(proto)) { continue; } ProtoFileElement element = null; for (Path directory : directories) { Source source = source(proto, directory); if (source == null) { continue; } try { Location location = Location.get(directory.toString(), proto); String data = Okio.buffer(source).readUtf8(); element = ProtoParser.parse(location, data); } catch (IOException e) { throw new IOException("Failed to load " + proto + " from " + directory, e); } finally { source.close(); } } if (element == null) { throw new FileNotFoundException("Failed to locate " + proto + " in " + sources); } ProtoFile protoFile = ProtoFile.get(element); loaded.put(proto, protoFile); // Queue dependencies to be loaded. for (String importPath : element.imports()) { protos.addLast(importPath); } } return new Linker(loaded.values()).link(); }
public static boolean bfsIterative(TreeNode root, int val) { Deque<TreeNode> s = new LinkedList<>(); s.push(root); while (!s.isEmpty()) { TreeNode curr = s.removeFirst(); if (curr.left != null) s.addLast(curr.left); if (curr.right != null) s.addLast(curr.right); if (curr.value == val) return true; } return false; }
@Override public void run() { while (true) { if (!messages.isEmpty()) { // Retrieve the first message and treat it NetMessage mess = messages.removeFirst(); treatMessage(mess); } ZUtils.sleep(500); } }