VoltMessage drain() { if (!m_servedFragment && m_firstFragment != null) { m_servedFragment = true; return m_firstFragment; } else if (!m_sequencedMessages.isEmpty()) { return m_sequencedMessages.poll(); } else { return m_blockedMessages.poll(); } }
public IColumn pollColumn() { IColumn column = blockColumns.poll(); if (column == null) { try { if (getNextBlock()) column = blockColumns.poll(); } catch (IOException e) { throw new RuntimeException(e); } } return column; }
/** Notification that the current request is finished */ public void requestDone() { connection.getSinkChannel().setConduit(originalSinkConduit); connection.getSourceChannel().setConduit(pushBackStreamSourceConduit); connection.getSinkChannel().suspendWrites(); connection.getSinkChannel().setWriteListener(null); if (anyAreSet(state, CLOSE_REQ)) { currentRequest = null; this.state |= CLOSED; IoUtils.safeClose(connection); } else if (anyAreSet(state, UPGRADE_REQUESTED)) { connection.getSourceChannel().suspendReads(); currentRequest = null; return; } currentRequest = null; HttpClientExchange next = pendingQueue.poll(); if (next == null) { // we resume reads, so if the target goes away we get notified connection.getSourceChannel().setReadListener(clientReadListener); connection.getSourceChannel().resumeReads(); } else { initiateRequest(next); } }
public int[] maxSlidingWindow(int[] nums, int k) { if (nums == null || k == 0) { return new int[0]; } int n = nums.length; int[] res = new int[n - k + 1]; Deque<Integer> dq = new ArrayDeque<>(); int pointer = 0; for (int i = 0; i < n; i++) { while (!dq.isEmpty() && dq.peek() < i - k + 1) { dq.poll(); } while (!dq.isEmpty() && nums[dq.peekLast()] < nums[i]) { dq.pollLast(); } dq.offer(i); if (i >= k - 1) { res[pointer++] = nums[dq.peek()]; } } return res; }
/** * Construct and return a new session object, based on the default settings specified by this * Manager's properties. The session id specified will be used as the session id. If a new session * cannot be created for any reason, return <code>null</code>. * * @param sessionId The session id which should be used to create the new session; if <code>null * </code>, a new session id will be generated * @exception IllegalStateException if a new session cannot be instantiated for any reason */ @Override public Session createSession(String sessionId) { if ((maxActiveSessions >= 0) && (getActiveSessions() >= maxActiveSessions)) { rejectedSessions++; throw new IllegalStateException(sm.getString("managerBase.createSession.ise")); } // Recycle or create a Session instance Session session = createEmptySession(); // Initialize the properties of the new session and return it session.setNew(true); session.setValid(true); session.setCreationTime(System.currentTimeMillis()); session.setMaxInactiveInterval(this.maxInactiveInterval); String id = sessionId; if (id == null) { id = generateSessionId(); } session.setId(id); sessionCounter++; SessionTiming timing = new SessionTiming(session.getCreationTime(), 0); synchronized (sessionCreationTiming) { sessionCreationTiming.add(timing); sessionCreationTiming.poll(); } return (session); }
/** Notify all the handshake futures about the failure during the handshake. */ private void setHandshakeFailure(Throwable cause) { // Release all resources such as internal buffers that SSLEngine // is managing. engine.closeOutbound(); try { engine.closeInbound(); } catch (SSLException e) { // only log in debug mode as it most likely harmless and latest chrome still trigger // this all the time. // // See https://github.com/netty/netty/issues/1340 String msg = e.getMessage(); if (msg == null || !msg.contains("possible truncation attack")) { logger.debug("SSLEngine.closeInbound() raised an exception.", e); } } notifyHandshakeFailure(cause); for (; ; ) { PendingWrite write = pendingUnencryptedWrites.poll(); if (write == null) { break; } write.failAndRecycle(cause); } }
@Override public void flush(ChannelHandlerContext ctx) throws Exception { // Do not encrypt the first write request if this handler is // created with startTLS flag turned on. if (startTls && !sentFirstMessage) { sentFirstMessage = true; for (; ; ) { PendingWrite pendingWrite = pendingUnencryptedWrites.poll(); if (pendingWrite == null) { break; } ctx.write(pendingWrite.msg(), (ChannelPromise) pendingWrite.recycleAndGet()); } ctx.flush(); return; } if (pendingUnencryptedWrites.isEmpty()) { pendingUnencryptedWrites.add(PendingWrite.newInstance(Unpooled.EMPTY_BUFFER, null)); } if (!handshakePromise.isDone()) { flushedBeforeHandshakeDone = true; } wrap(ctx, false); ctx.flush(); }
private static void solve(State initState) { Set<State> visited = new HashSet<State>(); Map<State, State> pred = new HashMap<State, State>(); Map<State, Integer> dist = new HashMap<State, Integer>(); Deque<State> bfs = new ArrayDeque<State>(); bfs.offer(initState); dist.put(initState, 0); while (bfs.size() > 0) { State s = bfs.poll(); int n = dist.get(s); visited.add(s); if (s.isFinal()) { outputState(s, pred); return; } for (State child : s.getChildren()) { if (visited.contains(child)) continue; if (!pred.containsKey(child)) pred.put(child, s); if (!dist.containsKey(child)) { dist.put(child, n + 1); bfs.offer(child); } } } System.out.printf("%d %d %d\n", initState.a, initState.b, initState.c); System.out.println("============"); }
// trim unnecessary log messages. private void truncate(long handle, boolean isSP) { // MIN value means no work to do, is a startup condition if (handle == Long.MIN_VALUE) { return; } Deque<RepairLog.Item> deq = null; if (isSP) { deq = m_logSP; if (m_truncationHandle < handle) { m_truncationHandle = handle; for (TransactionCommitInterest interest : m_txnCommitInterests) { interest.transactionCommitted(m_truncationHandle); } } } else { deq = m_logMP; } RepairLog.Item item = null; while ((item = deq.peek()) != null) { if (item.canTruncate(handle)) { deq.poll(); } else { break; } } }
public T get() { synchronized (mDataStore) { Object localObject2 = mDataStore.poll(); ??? = localObject2; if (localObject2 == null) { ??? = mCallback.newInstance(); }
public static void show(List<GPSState> states) { Deque<DeepTripState> boards = new LinkedList<DeepTripState>(); for (GPSState state : states) { boards.push((DeepTripState) state); } GameViewer viewer = new GameViewer("test", boards.poll().getBoard()); while (boards.peek() != null) { try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } viewer.refresh(boards.poll().getBoard()); } }
VoltMessage poll() { if (!isReady()) return null; if (!m_servedFragment) { m_servedFragment = true; return m_firstFragment; } else { return m_sequencedMessages.poll(); } }
private KafkaProducer getThreadLocalProducer() throws QiaoOperationException { KafkaProducer producer = threadLocalProducers.get(); if (producer == null) { producer = producersStack.poll(); if (producer == null) throw new QiaoOperationException("No producer available"); threadLocalProducers.set(producer); } return producer; }
protected IColumn computeNext() { while (true) { IColumn column = blockColumns.poll(); if (column != null && isColumnNeeded(column)) return column; try { if (column == null && !fetcher.getNextBlock()) return endOfData(); } catch (IOException e) { throw new RuntimeException(e); } } }
private TreeNode buildTree(Deque<String> nodes) { String val = nodes.poll(); // Get a value from queue and build node if (NULLNODE.equals(val)) { return null; } TreeNode node = new TreeNode(Integer.valueOf(val)); node.left = buildTree(nodes); // Build left subtree node.right = buildTree(nodes); // Build right subtree return node; }
private PooledPacket getPacket() { PooledPacket result; synchronized (this) { result = recycle.poll(); } if (result == null) return new PooledPacket(new AVPacket()).alloc(); return result; }
@VisibleForTesting IToken nextToken(final Supplier<Deque<IRobotLineElement>> elementsQueueSupplier) { if (tokensToAnalyze == null) { tokensToAnalyze = elementsQueueSupplier.get(); final IRobotLineElement firstToken = tokensToAnalyze.peekFirst(); if (firstToken != null) { currentOffsetInToken = rangeOffset - firstToken.getStartOffset(); } } if (tokensToAnalyze.isEmpty()) { lastTokenPosition = new Position(getTokenOffset() + getTokenLength(), 0); return Token.EOF; } final IRobotLineElement nextToken = tokensToAnalyze.poll(); for (final ISyntaxColouringRule rule : rules) { if (!rule.isApplicable(nextToken)) { continue; } final Optional<PositionedTextToken> tok = rule.evaluate(nextToken, currentOffsetInToken, analyzedTokens); if (tok.isPresent()) { final PositionedTextToken textToken = tok.get(); lastTokenPosition = textToken.getPosition(); if (lastTokenPosition.offset + lastTokenPosition.length >= nextToken.getStartOffset() + nextToken.getText().length()) { // rule have consumed whole Robot Token currentOffsetInToken = 0; analyzedTokens.add(nextToken); } else { // the token needs more coloring, so return it to queue and shift the // offset currentOffsetInToken = lastTokenPosition.getOffset() + lastTokenPosition.getLength() - nextToken.getStartOffset(); tokensToAnalyze.addFirst(nextToken); } return textToken.getToken(); } } lastTokenPosition = new Position( nextToken.getStartOffset() + currentOffsetInToken, nextToken.getText().length() - currentOffsetInToken); currentOffsetInToken = 0; analyzedTokens.add(nextToken); return ISyntaxColouringRule.DEFAULT_TOKEN; }
public String[] generateBinaryNumbers(final int n) { final Deque<String> q = new LinkedList<>(); final String[] binaryNumbers = new String[n]; q.add("1"); for (int i = 1; i <= n; i++) { final String number = q.poll(); binaryNumbers[i - 1] = number; q.add(number + "0"); q.add(number + "1"); } return binaryNumbers; }
@Override public void handlerRemoved0(ChannelHandlerContext ctx) throws Exception { if (decodeOut != null) { decodeOut.release(); decodeOut = null; } for (; ; ) { PendingWrite write = pendingUnencryptedWrites.poll(); if (write == null) { break; } write.failAndRecycle(new ChannelException("Pending write on removal of SslHandler")); } }
@Override public void incrementFont(float incr) { Deque<Component> components = new ArrayDeque<>(); components.addAll(Arrays.asList(getComponents())); Component c = null; while (null != (c = components.poll())) { Font f = c.getFont(); c.setFont(f.deriveFont(f.getSize2D() + incr)); if (c instanceof Container) { components.addAll(Arrays.asList(Container.class.cast(c).getComponents())); } } }
private void runEvictionIfRequired() { while (currentTableSize > maxTableSize) { TableEntry next = evictionQueue.poll(); if (next == null) { return; } currentTableSize -= next.size; List<TableEntry> list = dynamicTable.get(next.name); list.remove(next); if (list.isEmpty()) { dynamicTable.remove(next.name); } } }
public static void collectAllInterfaces(ITypeBinding type, Set<ITypeBinding> interfaces) { Deque<ITypeBinding> typeQueue = Lists.newLinkedList(); while (type != null) { typeQueue.add(type); type = type.getSuperclass(); } while (!typeQueue.isEmpty()) { ITypeBinding nextType = typeQueue.poll(); List<ITypeBinding> newInterfaces = Arrays.asList(nextType.getInterfaces()); interfaces.addAll(newInterfaces); typeQueue.addAll(newInterfaces); } }
// https://www.hackerrank.com/challenges/bfsshortreach public static String shortestReach(int[][] edges, int n, int e, int start) { Map<Integer, List<Integer>> map = new HashMap<>(); int[] nodes = new int[n]; Arrays.fill(nodes, -1); for (int i = 0; i < e; i++) { int a = edges[i][0], b = edges[i][1]; List<Integer> al = map.get(a); if (al == null) { al = new ArrayList<>(); map.put(a, al); } al.add(b); al = map.get(b); if (al == null) { al = new ArrayList<>(); map.put(b, al); } al.add(a); } Deque<Integer> q = new ArrayDeque<>(); q.offer(start); nodes[start - 1] = 0; while (q.size() > 0) { int s = q.poll(); List<Integer> al = map.get(s); for (int i = 0; al != null && i < al.size(); i++) { int v = al.get(i); if (nodes[v - 1] == -1) { q.offer(v); nodes[v - 1] = nodes[s - 1] + 6; } } } StringBuilder sb = new StringBuilder(); for (int i = 0; i < n; i++) { if (nodes[i] != 0) { sb.append(nodes[i]).append(' '); } } return sb.substring(0, sb.length() - 1); }
@Override public boolean hasNext() { WalkState walkState = null; do { if (stateStack.isEmpty()) { return false; } walkState = stateStack.poll(); } while (walkState.isEnd()); nextFile = walkState.currentFiles[walkState.currentIndex++]; stateStack.push(walkState); if (nextFile.isDirectory()) { stateStack.push(new WalkState(nextFile.listFiles(), 0)); return hasNext(); } else { return true; } }
protected boolean slowCheck() { EntityPlayer player = Minecraft.getMinecraft().thePlayer; mOpen.clear(); mClosed.clear(); boolean newValue = false; // Boundry problems because doubles to ints suck, always pick the "good position" Pos current = new Pos(Math.ceil(player.posX), Math.ceil(player.posY), Math.ceil(player.posZ)); if (!goodSuccessor(current, null)) current = new Pos(Math.floor(player.posX), Math.floor(player.posY), Math.floor(player.posZ)); while (current != null && !newValue) { if (current.isExposed()) { newValue = true; break; } mOpen.addAll(successors(current)); mClosed.add(current); current = mOpen.poll(); } return newValue; }
public List<List<Integer>> zigzagLevelOrder(TreeNode root) { List<List<Integer>> res = new ArrayList<List<Integer>>(); if (root == null) { return res; } int curh = 1; // double ended queue Deque<TreeNode> queue = new LinkedList<TreeNode>(); queue.add(root); TreeNode head = root, tail = null; List<Integer> path = new ArrayList<Integer>(); while (!queue.isEmpty()) { TreeNode cur = queue.peek(); if (cur == head) { if (!queue.isEmpty()) { tail = queue.getLast(); } } queue.poll(); path.add(cur.val); if (cur.left != null) { queue.add(cur.left); } if (cur.right != null) { queue.add(cur.right); } if (cur == tail) { if (!queue.isEmpty()) { head = queue.getFirst(); } if ((curh & 1) == 0) { Collections.reverse(path); } res.add(new ArrayList<Integer>(path)); path.clear(); curh++; } } return res; }
/** * Remove this Session from the active Sessions for this Manager. * * @param session Session to be removed * @param update Should the expiration statistics be updated */ @Override public void remove(Session session, boolean update) { // If the session has expired - as opposed to just being removed from // the manager because it is being persisted - update the expired stats if (update) { long timeNow = System.currentTimeMillis(); int timeAlive = (int) (timeNow - session.getCreationTimeInternal()) / 1000; updateSessionMaxAliveTime(timeAlive); expiredSessions.incrementAndGet(); SessionTiming timing = new SessionTiming(timeNow, timeAlive); synchronized (sessionExpirationTiming) { sessionExpirationTiming.add(timing); sessionExpirationTiming.poll(); } } if (session.getIdInternal() != null) { sessions.remove(session.getIdInternal()); } }
/** * @param buffer * @param tile * @param pool * @return */ private Tile createTile( FloatBuffer buffer, Rectangle tile, GL gl, Deque<Texture> pool, TablePerspective tablePerspective) { final VirtualArray recordVA = tablePerspective.getRecordPerspective().getVirtualArray(); final VirtualArray dimVA = tablePerspective.getDimensionPerspective().getVirtualArray(); final ATableBasedDataDomain dataDomain = tablePerspective.getDataDomain(); final int ilast = tile.y + tile.height; final int jlast = tile.x + tile.width; // fill buffer buffer.rewind(); for (int i = tile.y; i < ilast; ++i) { int recordID = recordVA.get(i); for (int j = tile.x; j < jlast; ++j) { int dimensionID = dimVA.get(j); Color color = blockColorer.apply(recordID, dimensionID, dataDomain, false); buffer.put(color.getRGBA()); } } // load to texture buffer.rewind(); Texture texture; if (!pool.isEmpty()) texture = pool.poll(); else texture = TextureIO.newTexture(GL.GL_TEXTURE_2D); TextureData texData = asTextureData(buffer, tile.width, tile.height); texture.updateImage(gl, texData); gl.glFlush(); texData.destroy(); return new Tile(tile, texture); }
public void connectedComponents( GL4 gl, int toriBuffer, int edgesBuffer, int torusCount, int verticesBuffer, int vertexCount, int sphereCount) { boolean[][] adjacency = new boolean[vertexCount][vertexCount]; int[][] edges = new int[torusCount][2]; int[][] spheres = new int[torusCount][2]; // map surface edges buffer gl.glBindBuffer(GL_SHADER_STORAGE_BUFFER, edgesBuffer); IntBuffer edgesData = gl.glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY).asIntBuffer(); // fill adjacency matrix for (int i = 0; i < torusCount; i++) { int v0 = edgesData.get(4 * i); int v1 = edgesData.get(4 * i + 1); if (v0 != -1 && v1 != -1) { adjacency[v0][v1] = true; adjacency[v1][v0] = true; // store edges edges[i][0] = v0; edges[i][1] = v1; // get adjacent spheres spheres[i][0] = edgesData.get(4 * i + 2); spheres[i][1] = edgesData.get(4 * i + 3); } } // unmap edges buffer gl.glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); // create CSR representation of the adjacency matrix int count = 0; int[] rows = new int[vertexCount + 1]; rows[0] = count; for (int i = 0; i < vertexCount; i++) { for (int j = 0; j < vertexCount; j++) { if (adjacency[i][j]) { count++; } } rows[i + 1] = count; } int index = 0; int[] columns = new int[count]; for (int i = 0; i < vertexCount; i++) { for (int j = 0; j < vertexCount; j++) { if (adjacency[i][j]) { columns[index] = j; index++; } } } Deque<Integer> vertices = new ArrayDeque<>(); List<Integer> sizes = new ArrayList<>(); boolean[] visited = new boolean[vertexCount]; int[] labels = new int[vertexCount]; int label = 1; int startVertex; do { // find start vertex startVertex = -1; for (int i = 0; i < vertexCount; i++) { if (!visited[i]) { startVertex = i; break; } } if (startVertex < 0) { break; } // label one connected component using BFS int size = 0; vertices.add(startVertex); while (!vertices.isEmpty()) { int vertex = vertices.poll(); if (visited[vertex]) { continue; } visited[vertex] = true; labels[vertex] = label; int start = rows[vertex]; int end = rows[vertex + 1]; for (int i = start; i < end; i++) { vertices.add(columns[i]); } size++; } sizes.add(size); label++; } while (startVertex >= 0); // find largest connceted component int largest = 0; for (int i = 1; i < sizes.size(); i++) { if (sizes.get(i) > sizes.get(largest)) { largest = i; } } // map surface vertices buffer gl.glBindBuffer(GL_SHADER_STORAGE_BUFFER, verticesBuffer); IntBuffer verticesBuf = gl.glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_WRITE_ONLY).asIntBuffer(); // write surface/cavity flags for (int i = 0; i < labels.length; i++) { int value = labels[i] == (largest + 1) ? 1 : 0; verticesBuf.put(i, value); } // unmap edges buffer gl.glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); sphereCircles(gl, edges, spheres, sphereCount, toriBuffer, torusCount); try { writeCSR(rows, columns); writeLabels(labels, sizes); } catch (IOException ex) { ex.printStackTrace(System.err); } }
private ImapConnection pollConnection() { synchronized (connections) { return connections.poll(); } }