Java Code Examples for java.util.Queue#isEmpty()

private void bfs(Graph G, int s) {
	Queue<Integer> q = (Queue<Integer>) new LinkedList<Integer>();
	q.add(s);
	while (!q.isEmpty()) {
		int v = q.poll();
		marked[v] = true;
		for (int w : G.adj(v)) {
			if (!marked[w]) {
				marked[w] = true;
				edgeTo[w] = v;
				q.add(w);
			}
		}
	}

}
 

public static void levelOrder(Node root) 
{
    Queue<Node> queue = new LinkedList<>();
    queue.add(root);

    while (!queue.isEmpty()) 
    {
        Node curr = queue.remove();
        System.out.print(" "+curr.data);

        if (curr.left != null) 
          queue.add(curr.left);
        if (curr.right != null) 
          queue.add(curr.right);
    }
}
 

private void indexString(Queue<Character> charSequence, int depth) {
	if(charSequence.isEmpty()) {
		Preconditions.checkArgument(!(isRoot() && depth == 0), "Empty string is not a valid prefix");
		this.validPrefix = true;
	} else {
		Character c = charSequence.poll();
		Node childNode;
		if(children.containsKey(c))
			childNode = children.get(c);
		else {
			childNode = new Node(c);
			childNode.parent = this;
			children.put(c, childNode);
		}

		childNode.indexString(charSequence, depth + 1);
	}
}
 

@Override
public void breadthFirstSearch(Task root, Predicate<Pair<Task, Task>> predicate) {
  Preconditions.checkNotNull(root);
  Queue<Task> queue = Queues.newArrayDeque();
  if (predicate.apply(Pair.create((Task) null, root))) {
    queue.add(root);
  }
  while (!queue.isEmpty()) {
    Task head = queue.poll();
    for (Task child : head.getNestedTasks()) {
      if (predicate.apply(Pair.create(head, child))) {
        queue.add(child);
      }
    }
  }
}
 

private void addScopeAndAncestorsToScopeMap(Map<S, ScopeWrapper<S>> scopeMap, ScopeWrapper<S> scope) {

      if (scope == null) {
        return;
      }

      Queue<ScopeWrapper<S>> ancestors = new LinkedList<>();
      ancestors.add(scope);

      while (!ancestors.isEmpty()) {
        ScopeWrapper<S> thisScope = ancestors.poll();
        if (!scopeMap.containsKey(thisScope.getType())) {
          scopeMap.put(thisScope.getType(), thisScope);
        } else if (!scopeMap.get(thisScope.getType()).equals(thisScope)) {
          throw new IllegalStateException(String.format("Multiple scopes found with type %s but different identity: %s and %s.",
              thisScope.getType(), thisScope.getScope(), scopeMap.get(thisScope.getType()).getScope()));
        }
        ancestors.addAll(thisScope.getParentScopes());
      }
    }
 

private int drawStripesEndingBefore(int ys, @Nonnull Queue<PositionedStripe> ends, @Nonnull List<PositionedStripe> stripes, @Nonnull Graphics g, int yStart) {
  while (!ends.isEmpty()) {
    PositionedStripe endingStripe = ends.peek();
    if (endingStripe.yEnd > ys) break;
    ends.remove();

    // check whether endingStripe got obscured in the range yStart..endingStripe.yEnd
    int i = stripes.indexOf(endingStripe);
    stripes.remove(i);
    if (i == 0) {
      // visible
      drawSpot(g, endingStripe.thin, yStart, endingStripe.yEnd, endingStripe.color);
      yStart = endingStripe.yEnd;
    }
  }
  return yStart;
}
 

void printLevelOrder(Node root) {
    Queue<Node> queue = new LinkedList<Node>();
    queue.add(root);
    while (!queue.isEmpty()) {
 
        /* poll() removes the present head.
        For more information on poll() visit 
        http://www.tutorialspoint.com/java/util/linkedlist_poll.htm */
        Node tempNode = queue.poll();
        System.out.print(tempNode.data + " ");

        /*Enqueue left child */
        if (tempNode.left != null) {
            queue.add(tempNode.left);
        }

        /*Enqueue right child */
        if (tempNode.right != null) {
            queue.add(tempNode.right);
        }
    }
}
 

public static void exit(final Throwable thrown) {
  final Queue<Span> spans = spanHolder.get();
  if (spans.isEmpty())
    return;

  final Span span = spans.poll();
  if (thrown != null) {
    span.log(errorLogs(thrown));
    span.setTag(TAGS_KEY_ERROR, true);
    span.setTag(TAGS_KEY_ERROR_MESSAGE, thrown.getMessage());
    span.setTag(TAGS_KEY_HTTP_STATUS_CODE, 500);
  }
  else {
    span.setTag(TAGS_KEY_HTTP_STATUS_CODE, 200);
  }

  span.finish();
}
 

/**
 * 获取当前匹配树存在的匹配资源(URL+METHOD)数量
 * @return int 资源数量
 */
public int getResourceNum() {
    int resourceNum = 0;
    // 广度层级遍历
    Queue<Node> resourceList = new LinkedList<>();
    resourceList.add(root);
    while (!resourceList.isEmpty()) {
        Node currentNode = resourceList.poll();
        if (NODE_TYPE_METHOD.equals(currentNode.nodeType)) {
            resourceNum ++;
        }
        if (currentNode.getChildren() != null && !currentNode.getChildren().isEmpty()) {
            resourceList.addAll(currentNode.getChildren().values());
        }
    }
    if (logger.isDebugEnabled()) {
        logger.debug("sureness - current PathTree resource num is: {}", resourceNum);
    }
    return resourceNum;
}
 

@Override
public void handleSplitsChanges(Queue<SplitsChange<MockSourceSplit>> splitsChanges) {
	do {
		SplitsChange<MockSourceSplit> splitsChange = splitsChanges.poll();
		if (splitsChange instanceof SplitsAddition) {
			splitsChange.splits().forEach(s -> splits.put(s.splitId(), s));
		}
	} while (handleSplitsInOneShot && !splitsChanges.isEmpty());
}
 

/**
 * A deserialized serialized deque has same elements in same order
 */
public void testSerialization() throws Exception {
    Queue x = populatedDeque(SIZE);
    Queue y = serialClone(x);

    assertNotSame(y, x);
    assertEquals(x.size(), y.size());
    assertEquals(x.toString(), y.toString());
    assertTrue(Arrays.equals(x.toArray(), y.toArray()));
    while (!x.isEmpty()) {
        assertFalse(y.isEmpty());
        assertEquals(x.remove(), y.remove());
    }
    assertTrue(y.isEmpty());
}
 

public void resend(String name, Queue<PushNotification> queue) {
	IApnsService service = ApnsServiceImpl.getCachedService(name);
	if (service != null) {
		while (!queue.isEmpty()) {
			service.sendNotification(queue.poll());
		}
	} else {
		logger.error("Cached service is null. name: " + name);
	}
}
 

/**
 * Delete a storage group
 */
List<MeasurementMNode> deleteStorageGroup(String path) throws MetadataException {
  MNode cur = getNodeByPath(path);
  if (!(cur instanceof StorageGroupMNode)) {
    throw new StorageGroupNotSetException(path);
  }
  // Suppose current system has root.a.b.sg1, root.a.sg2, and delete root.a.b.sg1
  // delete the storage group node sg1
  cur.getParent().deleteChild(cur.getName());

  // collect all the LeafMNode in this storage group
  List<MeasurementMNode> leafMNodes = new LinkedList<>();
  Queue<MNode> queue = new LinkedList<>();
  queue.add(cur);
  while (!queue.isEmpty()) {
    MNode node = queue.poll();
    for (MNode child : node.getChildren().values()) {
      if (child instanceof MeasurementMNode) {
        leafMNodes.add((MeasurementMNode) child);
      } else {
        queue.add(child);
      }
    }
  }

  cur = cur.getParent();
  // delete node b while retain root.a.sg2
  while (!IoTDBConstant.PATH_ROOT.equals(cur.getName()) && cur.getChildren().size() == 0) {
    cur.getParent().deleteChild(cur.getName());
    cur = cur.getParent();
  }
  return leafMNodes;
}
 

@Override
public void deleteFolder(final Repository repository,
                         final String treePath,
                         final DateTime timestamp,
                         final BooleanSupplier cancelledCheck)
{
  boolean canDeleteComponent =
      securityHelper.isPermitted(new RepositoryViewPermission(repository, BreadActions.DELETE))[0];
  ComponentMaintenance componentMaintenance = repository.facet(ComponentMaintenance.class);
  Queue<String> paths = new PriorityQueue<>();
  paths.add(treePath);

  while (!cancelledCheck.getAsBoolean() && !paths.isEmpty()) {
    String basePath = paths.poll();
    List<String> path = Arrays.asList(basePath.split("/"));
    Iterable<BrowseNode<EntityId>> nodes =
        browseNodeStore.getByPath(repository.getName(), path, configuration.getMaxNodes());
    Iterator<BrowseNode<EntityId>> nodeIterator = nodes.iterator();

    while (!cancelledCheck.getAsBoolean() && nodeIterator.hasNext()) {
      BrowseNode<EntityId> node = nodeIterator.next();

      if (!node.isLeaf()) {
        paths.offer(basePath + "/" + node.getName());
      }
      else if (canDeleteComponent && node.getAssetId() == null && node.getComponentId() != null) {
        deleteComponent(repository, node.getComponentId(), timestamp, componentMaintenance);
      }

      if (node.getAssetId() != null) {
        deleteAsset(repository, node.getAssetId(), timestamp, componentMaintenance);
      }
    }
  }
}
 

private RecyclerView.ViewHolder getChildViewHolder(int viewType, ViewGroup parent) {
  final Queue<RecyclerView.ViewHolder> viewHolders = childViewHolderCache.get(viewType);
  if (!viewHolders.isEmpty()) {
    return viewHolders.poll();
  }
  RecyclerView.ViewHolder childViewHolder = childAdapterViewTypeDelegates.get(viewType).createViewHolder(parent);
  childViewHolder.itemView.setTag(new ChildViewState());
  return childViewHolder;
}
 

/**
 * Calls {@link ConfigConstraints#assertValid(Entity)} on the given entity and all of
 * its descendants.
 */
private void validateDescendantConfig(Entity e) {
    Queue<Entity> queue = Lists.newLinkedList();
    queue.add(e);
    while (!queue.isEmpty()) {
        Entity e1 = queue.poll();
        ConfigConstraints.assertValid(e1);
        queue.addAll(e1.getChildren());
    }
}
 

/**
 * 判断是否为完全二叉树
 */
public static boolean isCBT(Node head) {
    if (head == null) {
        return true;
    }
    Queue<Node> queue = new LinkedList<Node>();
    boolean leaf = false;
    Node left = null;
    Node right = null;
    queue.offer(head);
    while (!queue.isEmpty()) {
        head = queue.poll();
        left = head.left;
        right = head.right;
        // 有右孩子没有左孩子一定不是；如果两个孩子都没有，该结点下面结点必须是叶子结点；有左孩子没有右孩子则下面所有节点都是叶子节点。
        if ((leaf && (left != null || right != null)) || (left == null && right != null)) {
            return false;
        }
        if (left != null) {
            queue.offer(left);
        }
        if (right != null) {
            queue.offer(right);
        } else {
            // 左等于空或者右等于空 则开启。因为上面代码已经去掉左等于空的情况，因此这里只需要判断右是否为空；
            leaf = true;
        }
    }
    return true;
}
 

/**
 * Simple version (testing one by one), which is very slow. Only for testing purposes.
 *
 * @param position
 * @param mask
 * @param data
 * @param width
 * @param height
 * @param value
 */
public static void simple_fill(Vector2D position, byte[] mask, int[] data, int width, int height, int value) {

    // create queue and add initial position
    Queue<Vector2D> queue = new ArrayDeque<>();
    queue.add(position);

    // unit vectors in x and y direction
    final Vector2D ex = new Vector2D(1, 0);
    final Vector2D ey = new Vector2D(0, 1);

    // the heap loop
    while (!queue.isEmpty()) {
        // get next point
        Vector2D p = queue.remove();
        int i = p.x + p.y * width;

        if (mask[i] != 0) {
            // mark as processed and set data to value
            mask[i] = 0;
            data[i] = value;

            // up
            if (p.y > 0) {
                queue.add(Vector2D.subtract(p, ey));
            }
            // down
            if (p.y < height - 1) {
                queue.add(Vector2D.add(p, ey));
            }
            // left
            if (p.x > 0) {
                queue.add(Vector2D.subtract(p, ex));
            }
            // right
            if (p.x < width - 1) {
                queue.add(Vector2D.add(p, ex));
            }
        }
    }
}
 

/**
 * Converts a function call with a Union type input into a case statement, where each branch of the case corresponds to
 * one of the subtypes of the Union type. The function call is materialized in each of the branches, with the union input cast
 * to the specific type corresponding to the branch of the case statement
 * @param call
 * @param functionLookupContext
 * @return
 */
private LogicalExpression rewriteUnionFunction(FunctionCall call, FunctionLookupContext functionLookupContext) {
  LogicalExpression[] args = new LogicalExpression[call.args.size()];
  call.args.toArray(args);

  for (int i = 0; i < args.length; i++) {
    LogicalExpression arg = call.args.get(i);
    MajorType majorType = arg.getMajorType();

    if (majorType.getMinorType() != MinorType.UNION) {
      continue;
    }

    List<MinorType> subTypes = majorType.getSubTypeList();
    Preconditions.checkState(subTypes.size() > 0, "Union type has no subtypes");

    Queue<IfCondition> ifConditions = Lists.newLinkedList();

    for (MinorType minorType : subTypes) {
      LogicalExpression ifCondition = getIsTypeExpressionForType(minorType, arg.accept(new CloneVisitor(), null));
      args[i] = getUnionAssertFunctionForType(minorType, arg.accept(new CloneVisitor(), null));

      List<LogicalExpression> newArgs = Lists.newArrayList();
      for (LogicalExpression e : args) {
        newArgs.add(e.accept(new CloneVisitor(), null));
      }

      // When expanding the expression tree to handle the different subtypes, we will not throw an exception if one
      // of the branches fails to find a function match, since it is possible that code path will never occur in execution
      // So instead of failing to materialize, we generate code to throw the exception during execution if that code
      // path is hit.

      errorCollectors.push(errorCollector);
      errorCollector = new ErrorCollectorImpl();

      LogicalExpression thenExpression = new FunctionCall(call.getName(), newArgs, call.getPosition()).accept(this, functionLookupContext);

      if (errorCollector.hasErrors()) {
        thenExpression = getExceptionFunction(errorCollector.toErrorString());
      }

      errorCollector = errorCollectors.pop();

      IfExpression.IfCondition condition = new IfCondition(ifCondition, thenExpression);
      ifConditions.add(condition);
    }

    LogicalExpression ifExpression = ifConditions.poll().expression;

    while (!ifConditions.isEmpty()) {
      ifExpression = IfExpression.newBuilder().setIfCondition(ifConditions.poll()).setElse(ifExpression).build();
    }

    args[i] = ifExpression;
    return ifExpression.accept(this, functionLookupContext);
  }
  throw new UnsupportedOperationException("Did not find any Union input types");
}
 

protected final CircularElement<E> takeNext(BlockingQueue<CircularElement<E>> queue, Queue<CircularElement<E>> cache)
		throws InterruptedException {
	return cache.isEmpty() ? queue.take() : cache.poll();
}