Java Code Examples for java.util.LinkedList#pop()

@Override
public MemoryBlock allocate(long size) throws OutOfMemoryError {
  if (shouldPool(size)) {
    synchronized (this) {
      final LinkedList<WeakReference<MemoryBlock>> pool = bufferPoolsBySize.get(size);
      if (pool != null) {
        while (!pool.isEmpty()) {
          final WeakReference<MemoryBlock> blockReference = pool.pop();
          final MemoryBlock memory = blockReference.get();
          if (memory != null) {
            assert (memory.size() == size);
            return memory;
          }
        }
        bufferPoolsBySize.remove(size);
      }
    }
  }
  long[] array = new long[(int) ((size + 7) / 8)];
  return new MemoryBlock(array, Platform.LONG_ARRAY_OFFSET, size);
}
 

@Override
public Object visit(FuncDef df){
	currentFD.push(df);
	toCheckOnExit.put(df, new LinkedList<FuncDef>());
	Object ret = super.visit(df);

	LinkedList<FuncDef> toCheckOnExitx = toCheckOnExit.get(df);
	
	if(null != toCheckOnExitx && !toCheckOnExitx.isEmpty()){
		//LinkedList<FuncDef> proce = toCheckOnExitx;
		while(!toCheckOnExitx.isEmpty()){
			super.visit(toCheckOnExitx.pop());
			/*if(!toCheckOnExitx.isEmpty()){
				proce.push(toCheckOnExitx.pop());
			}*/
		}
	}
	
	
	//toCheckOnExit.remove(df);//comment out side something is causing early exit... maybe a copy?
	currentFD.pop();
	
	return ret;
}
 

/*******************
 * Handle a string element.
 * 
 * @param obj The RMIObject to populate with class names.
 ******************/
private void handleStringElement(LinkedList<Byte> dataStack) throws BaRMIeInvalidReplyDataPacketException {
	//Handle a string based on the type
	switch(dataStack.pop()) {
		//Standard string
		case ObjectStreamConstants.TC_STRING:
			this.extractUtf8(dataStack);
			break;
			
		//Long string
		case ObjectStreamConstants.TC_LONGSTRING:
			this.extractLongUtf8(dataStack);
			break;
			
		//References
		case ObjectStreamConstants.TC_REFERENCE:
			this.extractInt(dataStack);
			break;
			
		//Invalid string type
		default:
			throw new BaRMIeInvalidReplyDataPacketException("Invalid string element type.");
	}
}
 

protected <S> void findCycles(Nfa<S> nfa, S node, IAcceptor<List<S>> cycleAcceptor, Map<S, Integer> dfsMark,
		LinkedList<S> dfsStack) {
	dfsStack.push(node);
	dfsMark.put(node, DFS_ON_STACK);
	for (S follower : nfa.getFollowers(node)) {
		Integer followerMark = dfsMark.get(follower);
		if (followerMark == null) {
			// The follower is not visited yet, so go deeper.
			findCycles(nfa, follower, cycleAcceptor, dfsMark, dfsStack);
		} else if (followerMark == DFS_ON_STACK) {
			// If the follower is on the stack that means we have a cycle
			// that includes all nodes between
			// the follower node and the current node.
			LinkedList<S> cycle = Lists.newLinkedList();
			Iterator<S> stackIter = dfsStack.iterator();
			S cycleNode;
			do {
				cycleNode = stackIter.next();
				cycle.addFirst(cycleNode);
			} while (cycleNode != follower && stackIter.hasNext());
			cycleAcceptor.accept(cycle);
		}
	}
	dfsStack.pop();
	dfsMark.put(node, DFS_VISITED);
}
 

private static List<String> stubsToList(String[] stubIdsToPortMapping) {
	List<String> list = new ArrayList<>();
	if (stubIdsToPortMapping.length == 1 && !containsRange(stubIdsToPortMapping[0])) {
		list.addAll(StringUtils.commaDelimitedListToSet(stubIdsToPortMapping[0]));
		return list;
	}
	else if (stubIdsToPortMapping.length == 1
			&& containsRange(stubIdsToPortMapping[0])) {
		LinkedList<String> linkedList = new LinkedList<>();
		String[] split = stubIdsToPortMapping[0].split(",");
		for (String string : split) {
			if (containsClosingRange(string)) {
				String last = linkedList.pop();
				linkedList.push(last + "," + string);
			}
			else {
				linkedList.push(string);
			}
		}
		list.addAll(linkedList);
		return list;
	}
	Collections.addAll(list, stubIdsToPortMapping);
	return list;
}
 

private Thread createCopyThread2(PipedHostTelService service) {
    LinkedList<String> preCommand = new LinkedList<String>() {{
        this.addAll(Arrays.asList("help", "test", "exit"));
    }};
    return new Thread(() -> {
        while (!preCommand.isEmpty()) {
            try {
                Thread.sleep(200);
                String pop = preCommand.pop();
                if (StringUtils.isNotBlank(pop)) {
                    service.sendCommand(pop);
                }
            } catch (Exception e) { /**/ }
        }
    });
}
 

public BreadthFirstSorterImpl(FastDirectedGraph<N, FastGraphEdge<N>> graph, N entry) {
	LinkedList<N> queue = new LinkedList<>();
	queue.add(entry);
	
	Set<N> visited = new HashSet<>(graph.size());
	bfs = new ArrayList<>();
	while(!queue.isEmpty()) {
		entry = queue.pop();
		
		if(visited.contains(entry)) {
			continue;
		}
		visited.add(entry);
		bfs.add(entry);
		
		for(FastGraphEdge<N> e : graph.getEdges(entry)) {
			N s = e.dst();
			queue.addLast(s);
		}
	}
}
 

private String applyDatabaseSpecificOperators(LinkedList<String> operandStack, LinkedList<Operator> operatorStack) {
    List<String> operands = new ArrayList<>();
    while (operatorStack.size() != 0) {
        Operator operator = operatorStack.pop();
        while (operands.size() != operator.getOperandsCount()) {
            operands.add(operandStack.pop());
        }
        Collections.reverse(operands);
        operandStack.push(operator.process(operands));
        operands.clear();
    }
    return applyWordProcessors(operandStack.stream().collect(Collectors.joining()));
}
 

public List<EObjectChange> getAllEObjectRecordings() {
	LinkedList<EObjectChange> todo = new LinkedList<>();
	todo.addAll(roots);
	List<EObjectChange> result = Lists.newArrayList();
	while (!todo.isEmpty()) {
		EObjectChange next = todo.pop();
		result.add(next);
		todo.addAll(next.getChildren());
	}
	return result;
}
 

/**
 * Propagates node table of given DAG to all of it ancestors.
 */
private void bubbleUpNodeTable(DAGraph<DataT, NodeT> from, LinkedList<String> path) {
    if (path.contains(from.rootNode.key())) {
        path.push(from.rootNode.key()); // For better error message
        throw new IllegalStateException("Detected circular dependency: " + StringUtils.join(path, " -> "));
    }
    path.push(from.rootNode.key());
    for (DAGraph<DataT, NodeT> to : from.parentDAGs) {
        this.merge(from.nodeTable, to.nodeTable);
        this.bubbleUpNodeTable(to, path);
    }
    path.pop();
}
 

/**
 * 处理Span内部含有换行符转换为占满剩余行空间的多个元素队列
 *
 * @param seq 待处理Span队列
 * @return 处理后含有占满剩余行空间的Span队列
 */
private LinkedList<Span> spanLinebreakSplit(LinkedList<Span> seq) {
    LinkedList<Span> sps = new LinkedList<>();
    if (seq == null || seq.isEmpty()) {
        return sps;
    }
    while (!seq.isEmpty()) {
        Span pop = seq.pop();
        // 通过换行符对span内容进行分割，获取新的队列
        LinkedList<Span> spans = pop.splitLineBreak();
        sps.addAll(spans);
    }
    return sps;
}
 

private static void addDirectoryRecursively(
    TarArchiveOutputStream tarOut,
    String parentPath,
    File dir,
    long modTime,
    FilenameFilter filter)
    throws IOException {
  final int parentPathLength = parentPath.length() + 1;
  final LinkedList<File> q = new LinkedList<>();
  q.add(dir);
  while (!q.isEmpty()) {
    final File current = q.pop();
    final File[] list = current.listFiles();
    if (list != null) {
      for (File f : list) {
        if (filter.accept(current, f.getName())) {
          final String entryName =
              f.getAbsolutePath().substring(parentPathLength).replace('\\', '/');
          if (f.isDirectory()) {
            addDirectoryEntry(tarOut, entryName, f, modTime);
            q.push(f);
          } else if (f.isFile()) {
            addFileEntry(tarOut, entryName, f, modTime);
          }
        }
      }
    }
  }
}
 

public void middleDfs(TreeNode root, List<Integer> list) {
    if (root == null) {
        return;
    }
    LinkedList<TreeNode> stack = new LinkedList<>();
    while (root != null || !stack.isEmpty()) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
        root = stack.pop();
        list.add(root.val);
        root = root.right;
    }
}
 

@Override
public Set<PackingPlan.ContainerPlan> addContainers(
    Set<PackingPlan.ContainerPlan> containersToAdd) {
  Set<PackingPlan.ContainerPlan> remapping = new HashSet<>();
  if ("prompt".equalsIgnoreCase(Context.updatePrompt(config))
      && !hasConfirmedWithUser(containersToAdd.size())) {
    LOG.warning("Scheduler updated topology canceled.");
    return remapping;
  }

  // Do the actual containers adding
  LinkedList<Integer> newAddedContainerIds = new LinkedList<>(
      controller.addContainers(containersToAdd.size()));
  if (newAddedContainerIds.size() != containersToAdd.size()) {
    throw new RuntimeException(
        "Aurora returned different container count " + newAddedContainerIds.size()
        + "; input count was " + containersToAdd.size());
  }
  // Do the remapping:
  // use the `newAddedContainerIds` to replace the container id in the `containersToAdd`
  for (PackingPlan.ContainerPlan cp : containersToAdd) {
    PackingPlan.ContainerPlan newContainerPlan =
        new PackingPlan.ContainerPlan(
            newAddedContainerIds.pop(), cp.getInstances(),
            cp.getRequiredResource(), cp.getScheduledResource().orNull());
    remapping.add(newContainerPlan);
  }
  LOG.info("The remapping structure: " + remapping);
  return remapping;
}
 

public List<MenuItem> layoutMainPanelItems(List<MenuItem> menuItems, final int toolbarWidth) {
    int availableWidth = toolbarWidth;
    final LinkedList<MenuItem> remainingMenuItems = new LinkedList<>(menuItems);
    /*final LinkedList<MenuItem> overflowMenuItems = new LinkedList<>();
    for (MenuItem menuItem : menuItems) {
        if (menuItem.requiresOverflow()) {
            overflowMenuItems.add(menuItem); TODO
        } else {
            remainingMenuItems.add(menuItem);
        }
    }
    remainingMenuItems.addAll(overflowMenuItems);*/
    mMainPanel.removeAllViews();
    mMainPanel.setPaddingRelative(0, 0, 0, 0);
    boolean isFirstItem = true;
    while (!remainingMenuItems.isEmpty()) {
        final MenuItem menuItem = remainingMenuItems.peek();
        /*if (!isFirstItem && menuItem.requiresOverflow()) {
            break;
        }*/
        final View menuItemButton = createMenuItemButton(mContext, menuItem, mIconTextSpacing);
        if (menuItemButton instanceof LinearLayout) {
            ((LinearLayout) menuItemButton).setGravity(Gravity.CENTER);
        }
        if (isFirstItem) {
            menuItemButton.setPaddingRelative((int) (1.5 * menuItemButton.getPaddingStart()), menuItemButton.getPaddingTop(), menuItemButton.getPaddingEnd(), menuItemButton.getPaddingBottom());
        }
        boolean isLastItem = remainingMenuItems.size() == 1;
        if (isLastItem) {
            menuItemButton.setPaddingRelative(menuItemButton.getPaddingStart(), menuItemButton.getPaddingTop(), (int) (1.5 * menuItemButton.getPaddingEnd()), menuItemButton.getPaddingBottom());
        }
        menuItemButton.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
        final int menuItemButtonWidth = Math.min(menuItemButton.getMeasuredWidth(), toolbarWidth);
        final boolean canFitWithOverflow = menuItemButtonWidth <= availableWidth - mOverflowButtonSize.getWidth();
        final boolean canFitNoOverflow = isLastItem && menuItemButtonWidth <= availableWidth;
        if (canFitWithOverflow || canFitNoOverflow) {
            setButtonTagAndClickListener(menuItemButton, menuItem);
            //menuItemButton.setTooltipText(menuItem.getTooltipText()); TODO
            mMainPanel.addView(menuItemButton);
            final ViewGroup.LayoutParams params = menuItemButton.getLayoutParams();
            params.width = menuItemButtonWidth;
            menuItemButton.setLayoutParams(params);
            availableWidth -= menuItemButtonWidth;
            remainingMenuItems.pop();
        } else {
            break;
        }
        isFirstItem = false;
    }
    if (!remainingMenuItems.isEmpty()) {
        mMainPanel.setPaddingRelative(0, 0, mOverflowButtonSize.getWidth(), 0);
    }
    mMainPanelSize = measure(mMainPanel);
    return remainingMenuItems;
}
 

private static int extractJsonObjectEndPosition(String responseString, int beginPosition) {
    //记录当前尚未发现配对闭合的大括号
    LinkedList<String> braces = new LinkedList<String>();
    //记录当前字符是否在双引号中
    boolean inQuotes = false;
    //记录当前字符前面连续的转义字符个数
    int consecutiveEscapeCount = 0;
    //从待验签字符的起点开始遍历后续字符串，找出待验签字符串的终止点，终点即是与起点{配对的}
    for (int index = beginPosition; index < responseString.length(); ++index) {
        //提取当前字符
        char currentChar = responseString.charAt(index);

        //如果当前字符是"且前面有偶数个转义标记（0也是偶数）
        if (currentChar == '"' && consecutiveEscapeCount % 2 == 0) {
            //是否在引号中的状态取反
            inQuotes = !inQuotes;
        }
        //如果当前字符是{且不在引号中
        else if (currentChar == '{' && !inQuotes) {
            //将该{加入未闭合括号中
            braces.push("{");
        }
        //如果当前字符是}且不在引号中
        else if (currentChar == '}' && !inQuotes) {
            //弹出一个未闭合括号
            braces.pop();
            //如果弹出后，未闭合括号为空，说明已经找到终点
            if (braces.isEmpty()) {
                return index + 1;
            }
        }

        //如果当前字符是转义字符
        if (currentChar == '\\') {
            //连续转义字符个数+1
            ++consecutiveEscapeCount;
        } else {
            //连续转义字符个数置0
            consecutiveEscapeCount = 0;
        }
    }

    //如果没有找到配对的闭合括号，说明验签内容片段提取失败，直接尝试选取剩余整个响应字符串进行验签
    return responseString.length();
}
 

private void getDiscreteLevels(String species, SpeciesCollection S, Experiments experiments, Encodings L, int levels)
{
	int col = S.getColumn(species);
	double[] level = new double[levels + 1];
	double v = Double.NaN, vp = Double.NaN;
	int steps = 0;
	level[0] = 0;
	level[levels] = Double.POSITIVE_INFINITY;

	LinkedList<Double> values = new LinkedList<Double>();

	for (List<List<Double>> experiment : experiments.getExperiments())
	{
		for (int i = 0; i < experiment.size(); i++)
		{
			double value = experiment.get(i).get(col);

			values.add(value);
		}
	}

	Collections.sort(values);

	for (int j = 1; j < levels - 1; j++)
	{
		int count = 0;
		level[j] = Double.POSITIVE_INFINITY;

		steps = values.size() / (levels - j + 1);

		while (values.size() > 0 && count < steps)
		{
			v = values.pop();

			count++;
		}

		do
		{
			vp = values.pop();
		}
		while (values.size() > 0 && v == vp);

		if (values.size() > 0)
		{
			level[j] = v;
			values.addFirst(vp);
		}
	}

	L.addDiscreteSpecies(col, level);
}
 

private static void copy(
    File source, File target, FilenameFilter filter, boolean nio, boolean replaceIfExists)
    throws IOException {
  if (source.isDirectory()) {
    if (!(target.exists() || target.mkdirs())) {
      throw new IOException(
          String.format("Unable create directory '%s'. ", target.getAbsolutePath()));
    }
    if (filter == null) {
      filter = ANY_FILTER;
    }
    String sourceRoot = source.getAbsolutePath();
    LinkedList<File> q = new LinkedList<>();
    q.add(source);
    while (!q.isEmpty()) {
      File current = q.pop();
      File[] list = current.listFiles();
      if (list != null) {
        for (File f : list) {
          if (!filter.accept(current, f.getName())) {
            continue;
          }
          File newFile = new File(target, f.getAbsolutePath().substring(sourceRoot.length() + 1));
          if (f.isDirectory()) {
            if (!(newFile.exists() || newFile.mkdirs())) {
              throw new IOException(
                  String.format("Unable create directory '%s'. ", newFile.getAbsolutePath()));
            }
            if (!f.equals(target)) {
              q.push(f);
            }
          } else {
            if (nio) {
              nioCopyFile(f, newFile, replaceIfExists);
            } else {
              copyFile(f, newFile, replaceIfExists);
            }
          }
        }
      }
    }
  } else {
    File parent = target.getParentFile();
    if (!(parent.exists() || parent.mkdirs())) {
      throw new IOException(
          String.format("Unable create directory '%s'. ", parent.getAbsolutePath()));
    }
    if (nio) {
      nioCopyFile(source, target, replaceIfExists);
    } else {
      copyFile(source, target, replaceIfExists);
    }
  }
}
 

public static int simulateCuboidGeneration(CubeDesc cubeDesc, boolean validate) {
    CuboidScheduler scheduler = cubeDesc.getInitialCuboidScheduler();
    long baseCuboid = Cuboid.getBaseCuboidId(cubeDesc);
    Collection<Long> cuboidSet = new TreeSet<Long>();
    cuboidSet.add(baseCuboid);
    LinkedList<Long> cuboidQueue = new LinkedList<Long>();
    cuboidQueue.push(baseCuboid);
    while (!cuboidQueue.isEmpty()) {
        long cuboid = cuboidQueue.pop();
        Collection<Long> spnanningCuboids = scheduler.getSpanningCuboid(cuboid);
        for (Long sc : spnanningCuboids) {
            boolean notfound = cuboidSet.add(sc);
            if (!notfound) {
                throw new IllegalStateException("Find duplicate spanning cuboid " + sc + " from cuboid " + cuboid);
            }

            cuboidQueue.push(sc);

        }
    }

    boolean enableDimCap = false;
    for (AggregationGroup agg : cubeDesc.getAggregationGroups()) {
        if (agg.getDimCap() > 0) {
            enableDimCap = true;
            break;
        }
    }

    if (validate) {
        if (enableDimCap) {
            if (cubeDesc.getAllCuboids().size() != cuboidSet.size()) {
                throw new IllegalStateException("Expected cuboid set " + cubeDesc.getAllCuboids() + "; but actual cuboid set " + cuboidSet);
            }
        } else {
            //only run this for test purpose, performance is bad when # of dims is large
            TreeSet<Long> enumCuboids = enumCalcCuboidCount(cubeDesc);
            System.out.println(Arrays.toString(enumCuboids.toArray(new Long[enumCuboids.size()])));
            if (enumCuboids.equals(cuboidSet) == false) {
                throw new IllegalStateException("Expected cuboid set " + enumCuboids + "; but actual cuboid set " + cuboidSet);
            }

            //check all valid and invalid
            for (long i = 0; i < baseCuboid; ++i) {
                if (cuboidSet.contains(i)) {
                    if (!scheduler.isValid(i)) {
                        throw new RuntimeException();
                    }

                    if (scheduler.findBestMatchCuboid(i) != i) {
                        throw new RuntimeException();
                    }
                } else {
                    if (scheduler.isValid(i)) {
                        throw new RuntimeException();
                    }

                    long corrected = scheduler.findBestMatchCuboid(i);
                    if (corrected == i) {
                        throw new RuntimeException();
                    }

                    if (!scheduler.isValid(corrected)) {
                        throw new RuntimeException();
                    }

                    if (scheduler.findBestMatchCuboid(corrected) != corrected) {
                        throw new RuntimeException();
                    }
                }
            }
        }
    }

    return cuboidSet.size();

}
 

private LinkedList<Integer> findActiveBreakpointsChildren(int selectedNodeNumber) {
	
	//a list of breakpoints...
	
	LinkedList<Integer> linkedList = new LinkedList<Integer>();
	int[] nodeBreakpointNumber = new int[numNodes];
				
	//int[] nodeStatus = new int[numNodes];
	//for(int i=0; i < numNodes; i ++){
	//	nodeStatus[i] = -1;
	//}
	
	//convert to easy process format.
	//for(int i=0; i < (binSize ); i++){
	//	if((int) indicators.getParameterValue(i) ==1){
	//		  nodeStatus[(int)breakPoints.getParameterValue(i)] = i;
	//	}
	//}
	
	//process the tree and get the vLoc of the viruses..
	//breadth first depth first..
	NodeRef cNode = treeModel.getRoot();
    LinkedList<NodeRef> visitlist = new LinkedList<NodeRef>();

    
    visitlist.add(cNode);
    
    
    //I am not sure if it still works......
    
    int countProcessed=0;
    while(visitlist.size() > 0){
    	
    	
    	countProcessed++;
    	//assign value to the current node...
    	if(treeModel.getParent(cNode) == null){
    		//Parameter curMu = mu.getParameter(0);
    		nodeBreakpointNumber[cNode.getNumber()] =   cNode.getNumber();
    	}
    	else{
    		nodeBreakpointNumber[cNode.getNumber()] =   nodeBreakpointNumber[treeModel.getParent(cNode).getNumber()];
    		//System.out.println("node#" + cNode.getNumber() + " is " + nodeBreakpointNumber[cNode.getNumber()]); 

    		if( (int) indicators.getParameterValue(cNode.getNumber()) == 1){
    			//System.out.println(cNode.getNumber() + " is a break point");
	    		//Parameter curMu = mu.getParameter(cNode.getNumber() +1); //+1 because mu0 is reserved for the root.
    			//Parameter curMu = mu.getParameter(cNode.getNumber() ); //+1 because mu0 is reserved for the root.
	    		
	    		//see if parent's status is the same as the selectedIndex
	    		if( nodeBreakpointNumber[cNode.getNumber()] ==   selectedNodeNumber ){
	    			//System.out.println("hihi");
	    			linkedList.add( cNode.getNumber() );
	    		}
	    		//now, replace this nodeBreakpointNumber with its own node number
	    		nodeBreakpointNumber[cNode.getNumber()] = cNode.getNumber();
	    				    			  			    			
    		}
    	}
    	
    	
    	//add all the children to the queue
 			for(int childNum=0; childNum < treeModel.getChildCount(cNode); childNum++){
 				NodeRef node= treeModel.getChild(cNode,childNum);
 				visitlist.add(node);
 	        }
 			
  			
  		visitlist.pop(); //now that we have finished visiting this node, pops it out of the queue

 			if(visitlist.size() > 0){
 				cNode = visitlist.getFirst(); //set the new first node in the queue to visit
 			}
 			
		
    }
    
    //System.out.println("Now printing children of "  + selectedNodeNumber+":");
	//for(int i=0; i < linkedList.size(); i++){
	//	System.out.println( linkedList.get(i)  );
	//}
	
	return linkedList;
}