Java Stack.addAll方法代码示例

import java.util.Stack; //导入方法依赖的package包/类
@Override
public boolean visit(DependencyNode node) {
    if (root == null) {
        root = node;
        directs = new HashSet<DependencyNode>();
        path = new Stack<DependencyNode>();
        allPaths = new HashSet<Stack<DependencyNode>>();
        return true;
    }
    path.push(node);
    Artifact artifact = node.getArtifact();
    if (key.equals(artifact.getDependencyConflictId())) {
        if (!path.isEmpty()) {
            directs.add(path.firstElement());
            Stack<DependencyNode> copy = new Stack<DependencyNode>();
            copy.addAll(path);
            allPaths.add(copy);
        }
        return false;
    }
    return true;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public static Map<String, Long> getQuantiles(Long[] rtimes, long average) {
    Map<String, Long> result = new HashMap<>();
    Arrays.sort(rtimes);

    double[] quantiles = {0.0, 0.90, 0.95, 0.99, 1.00};

    Stack<Long> timings = new Stack<>();
    timings.addAll(Arrays.asList(rtimes));
    double level = 1.0;
    Long timing = 0L;
    long sqr_diffs = 0;
    for (int qn = quantiles.length - 1; qn >= 0; qn--) {
        double quan = quantiles[qn];
        while (level >= quan && !timings.empty()) {
            timing = timings.pop();
            level -= 1.0 / rtimes.length;
            sqr_diffs += timing * Math.pow(timing - average, 2);
        }
        result.put(getMetricLabel(quan), timing);
    }
    result.put("std", (long) Math.sqrt(sqr_diffs / rtimes.length));
    return result;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public ArrayList<Coordinate> expansionDFS(Grid gameboard, TerrainType terrain, Settlement settlement){
    ArrayList<Coordinate> hexesEncountered = settlement.getSettlementCoordinates();
    ArrayList<Coordinate> newHexesAdded = new ArrayList<>();
    Stack<Coordinate> coords = new Stack();
    coords.addAll(hexesEncountered);

    while(!coords.empty()){
        Coordinate currentAdjacentCoordinate = coords.pop();
        ArrayList<Coordinate> neighboringCoordinates = findAdjacentCoords(gameboard, terrain, currentAdjacentCoordinate);
        for(int i=0; i<neighboringCoordinates.size(); i++){
            if(SettlementExpansionRules.contains(hexesEncountered, neighboringCoordinates.get(i))== false){
                newHexesAdded.add(neighboringCoordinates.get(i));
                hexesEncountered.add(neighboringCoordinates.get(i));
                coords.push(neighboringCoordinates.get(i));
            }
        }
    }
    return newHexesAdded;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public ArrayList<Coordinate> expansionDFS(Grid gameboard, TerrainType terrain, Settlement settlement){
    ArrayList<Coordinate> hexesEncountered = settlement.getSettlementCoordinates();
    ArrayList<Coordinate> newHexesAdded = new ArrayList<>();
    Stack<Coordinate> coords = new Stack();
    coords.addAll(hexesEncountered);

    while(!coords.empty()){
        Coordinate currentAdjacentCoordinate = coords.pop();
        ArrayList<Coordinate> neighboringCoordinates = findAdjacentCoords(gameboard, terrain, currentAdjacentCoordinate);
        for(int i=0; i<neighboringCoordinates.size(); i++){
            if(contains(hexesEncountered, neighboringCoordinates.get(i))== false){
                newHexesAdded.add(neighboringCoordinates.get(i));
                hexesEncountered.add(neighboringCoordinates.get(i));
                coords.push(neighboringCoordinates.get(i));
            }
        }
    }
    return newHexesAdded;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public boolean oneHive(Tile toMove) {
	List<Tile> list = getPieceNeighbors(toMove);

	if (toMove.getZ() != 0 || list.isEmpty())
		return true;

	HashSet<Tile> visited = new HashSet<Tile>();
	Stack<Tile> nextTiles = new Stack<Tile>();

	visited.add(toMove);
	nextTiles.add(list.get(0));
	Tile current;
	while (!nextTiles.isEmpty()) {
		if (!visited.contains(current = nextTiles.pop())) {
			nextTiles.addAll(getPieceNeighbors(current));
			visited.add(current);
		}
	}
	return getNbPieceOnTheBoard() == visited.size();
}
 

import java.util.Stack; //导入方法依赖的package包/类
@Override
synchronized public void added ( final ItemDescriptor descriptor )
{
    if ( this.itemList.containsKey ( descriptor ) )
    {
        return;
    }

    final String[] groupingArray = this.groupProvider.getGrouping ( descriptor );
    if ( groupingArray == null )
    {
        return;
    }

    final Stack<String> pathStack = new Stack<String> ();
    pathStack.addAll ( Arrays.asList ( reverse ( groupingArray ) ) );

    final GroupSubFolder subFolder = this.folder.add ( pathStack, descriptor );

    if ( subFolder != null )
    {
        this.itemList.put ( descriptor, subFolder );
    }
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Return all child nodes for the current node (none, if this is a leaf node).
 */
public List<TreebankTreeNode> allChildren() {
    Set<TreebankTreeNode> results = new HashSet<>();
    Stack<TreebankTreeNode> stack = new Stack<>();
    stack.push(this);
    while (!stack.isEmpty()) {
        TreebankTreeNode current = stack.pop();
        if (!results.contains(current)) {
            results.add(current);
            if (current.children.size() == 0) {
                results.add(current);
            }
            stack.addAll(Lists.reverse(current.children));
        }
    }
    return results.stream()
            .sorted(Comparator.comparingInt(t -> t.id))
            .collect(Collectors.toList());
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Returns the first descendant of a component that is an
 * <code>RTextArea</code>.  This is primarily here to support
 * <code>javax.swing.JLayer</code>s that wrap <code>RTextArea</code>s.
 *
 * @param comp The component to recursively look through.
 * @return The first descendant text area, or <code>null</code> if none
 *         is found.
 */
private static RTextArea getFirstRTextAreaDescendant(Component comp) {
	Stack<Component> stack = new Stack<Component>();
	stack.add(comp);
	while (!stack.isEmpty()) {
		Component current = stack.pop();
		if (current instanceof RTextArea) {
			return (RTextArea)current;
		}
		if (current instanceof Container) {
			Container container = (Container)current;
			stack.addAll(Arrays.asList(container.getComponents()));
		}
	}
	return null;
}
 

import java.util.Stack; //导入方法依赖的package包/类
@DataProvider(name="listProvider", parallel=true)
public static Object[][] listCases() {
    final List<Object[]> cases = new LinkedList<>();
    cases.add(new Object[] { Collections.emptyList() });
    cases.add(new Object[] { new ArrayList<>() });
    cases.add(new Object[] { new LinkedList<>() });
    cases.add(new Object[] { new Vector<>() });
    cases.add(new Object[] { new Stack<>() });
    cases.add(new Object[] { new CopyOnWriteArrayList<>() });
    cases.add(new Object[] { Arrays.asList() });

    List<Integer> l = Arrays.asList(42);
    cases.add(new Object[] { new ArrayList<>(l) });
    cases.add(new Object[] { new LinkedList<>(l) });
    cases.add(new Object[] { new Vector<>(l) });
    Stack<Integer> s = new Stack<>(); s.addAll(l);
    cases.add(new Object[]{s});
    cases.add(new Object[] { new CopyOnWriteArrayList<>(l) });
    cases.add(new Object[] { l });
    return cases.toArray(new Object[0][cases.size()]);
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Entry point into parsing command line arguments.
 * @param args the command line arguments
 * @return a list with all commands and subcommands initialized by this method
 * @throws ParameterException if the specified command line arguments are invalid
 */
List<CommandLine> parse(String... args) {
    Assert.notNull(args, "argument array");
    if (tracer.isInfo()) {tracer.info("Parsing %d command line args %s%n", args.length, Arrays.toString(args));}
    List<String> expanded = new ArrayList<String>();
    for (String arg : args) { addOrExpand(arg, expanded, new LinkedHashSet<String>()); }
    Stack<String> arguments = new Stack<String>();
    arguments.addAll(reverseList(expanded));
    List<CommandLine> result = new ArrayList<CommandLine>();
    parse(result, arguments, args);
    return result;
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Read data from the given JSONArray and populate the given Collection
 * 
 * @param json_array
 * @param catalog_db
 * @param collection
 * @param inner_classes
 * @throws Exception
 */
@SuppressWarnings("unchecked")
protected static void readCollectionField(final JSONArray json_array, final Database catalog_db, final Collection collection, final Stack<Class<?>> inner_classes) throws Exception {
    // We need to figure out what the inner type of the collection is
    // If it's a Collection or a Map, then we need to instantiate it before
    // we can call readFieldValue() again for it.
    Class<?> inner_class = inner_classes.pop();
    Collection<Class<?>> inner_interfaces = ClassUtil.getInterfaces(inner_class);
    final Stack<Class<?>> next_inner_classes = new Stack<Class<?>>();
    
    for (int i = 0, cnt = json_array.length(); i < cnt; i++) {
        if (i > 0) next_inner_classes.clear();
        next_inner_classes.addAll(inner_classes);
        assert (next_inner_classes.equals(inner_classes));
        Object value = null;

        // Null
        if (json_array.isNull(i)) {
            value = null;
            // Lists
        } else if (inner_interfaces.contains(List.class)) {
            value = new ArrayList<Object>();
            readCollectionField(json_array.getJSONArray(i), catalog_db, (Collection<?>) value, next_inner_classes);
            // Sets
        } else if (inner_interfaces.contains(Set.class)) {
            value = new HashSet<Object>();
            readCollectionField(json_array.getJSONArray(i), catalog_db, (Collection<?>) value, next_inner_classes);
            // Maps
        } else if (inner_interfaces.contains(Map.class)) {
            value = new HashMap<Object, Object>();
            readMapField(json_array.getJSONObject(i), catalog_db, (Map<Object, Object>) value, next_inner_classes);
            // Values
        } else {
            String json_string = json_array.getString(i);
            value = JSONUtil.getPrimitiveValue(json_string, inner_class, catalog_db);
        }
        collection.add(value);
    } // FOR
    return;
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 *
 * @param exps
 */
public static AbstractExpression combine(List<AbstractExpression> exps) {
    Stack<AbstractExpression> stack = new Stack<AbstractExpression>();
    stack.addAll(exps);

    if (stack.isEmpty()) {
        return null;
    } else if (stack.size() == 1) {
        return stack.pop();
    }
    AbstractExpression ret = null;
    while (stack.size() > 1) {
        AbstractExpression child_exp = stack.pop();
        //
        // If our return node is null, then we need to make a new one
        //
        if (ret == null) {
            ret = new ConjunctionExpression(ExpressionType.CONJUNCTION_AND);
            ret.setLeft(child_exp);
        //
        // Check whether we can add it to the right side
        //
        } else if (ret.getRight() == null) {
            ret.setRight(child_exp);
            stack.push(ret);
            ret = null;
        }
    }
    if (ret == null) {
        ret = stack.pop();
    } else {
        ret.setRight(stack.pop());
    }
    return ret;
}
 

import java.util.Stack; //导入方法依赖的package包/类
private static float canBreak(Stack<Position> stack, HorizontalBox hbox,
		float width) {
	List<Box> children = hbox.children;
	float[] cumWidth = new float[children.size() + 1];
	cumWidth[0] = 0;
	for (int i = 0; i < children.size(); i++) {
		Box box = children.get(i);
		cumWidth[i + 1] = cumWidth[i] + box.width;
		if (cumWidth[i + 1] > width) {
			int pos = getBreakPosition(hbox, i);
			if (box instanceof HorizontalBox) {
				Stack<Position> newStack = new Stack<Position>();
				float w = canBreak(newStack, (HorizontalBox) box, width
						- cumWidth[i]);
				if (w != box.width
						&& (cumWidth[i] + w <= width || pos == -1)) {
					stack.push(new Position(i - 1, hbox));
					stack.addAll(newStack);
					return cumWidth[i] + w;
				}
			}

			if (pos != -1) {
				stack.push(new Position(pos, hbox));
				return cumWidth[pos];
			}
		}
	}

	return hbox.width;
}
 

import java.util.Stack; //导入方法依赖的package包/类
public static Result tick(BehaviorTree tree, BehaviorData data)
{
	Cursor cursor = new Cursor(tree, data);

	tree.onStart(data);
	Result r = tree.getRoot().execute(cursor);
	cursor.onTreeResult(r);

	Stack<Node> prevOpenNodes = cursor.getBehaviorData().getData(cursor.getBehaviorTree().id, null).get("_open_nodes", new Stack<Node>());
	Stack<Node> openNodes = new Stack<Node>();
	openNodes.addAll(cursor.getOpenNodes());

	int start = 0;
	for (int i = 0; i < Math.min(prevOpenNodes.size(), openNodes.size()); ++i)
	{
		start = i + 1;
		if (prevOpenNodes.get(i) != openNodes.get(i))
		{
			break;
		}
	}

	for (int i = prevOpenNodes.size() - 1; i >= start; --i)
	{
		prevOpenNodes.get(i).close(cursor);
	}

	cursor.getBehaviorData().getData(cursor.getBehaviorTree().id, null).set("_open_nodes", openNodes);
	return r;
}
 

import java.util.Stack; //导入方法依赖的package包/类
/**
 * Read data from the given JSONObject and populate the given Map
 * 
 * @param json_object
 * @param catalog_db
 * @param map
 * @param inner_classes
 * @throws Exception
 */
@SuppressWarnings("unchecked")
protected static void readMapField(final JSONObject json_object, final Database catalog_db, final Map map, final Stack<Class<?>> inner_classes) throws Exception {
    Class<?> key_class = inner_classes.pop();
    Class<?> val_class = inner_classes.pop();
    Collection<Class<?>> val_interfaces = ClassUtil.getInterfaces(val_class);
    final Stack<Class<?>> next_inner_classes = new Stack<Class<?>>();
    
    assert (json_object != null);
    for (String json_key : CollectionUtil.iterable(json_object.keys())) {
        next_inner_classes.clear();
        next_inner_classes.addAll(inner_classes);
        assert (next_inner_classes.equals(inner_classes));

        // KEY
        Object key = JSONUtil.getPrimitiveValue(json_key, key_class, catalog_db);

        // VALUE
        Object object = null;
        if (json_object.isNull(json_key)) {
            // Nothing...
        } else if (val_interfaces.contains(List.class)) {
            object = new ArrayList<Object>();
            readCollectionField(json_object.getJSONArray(json_key), catalog_db, (Collection<?>) object, next_inner_classes);
        } else if (val_interfaces.contains(Set.class)) {
            object = new HashSet<Object>();
            readCollectionField(json_object.getJSONArray(json_key), catalog_db, (Collection<?>) object, next_inner_classes);
        } else if (val_interfaces.contains(Map.class)) {
            object = new HashMap<Object, Object>();
            readMapField(json_object.getJSONObject(json_key), catalog_db, (Map<?,?>) object, next_inner_classes);
        } else {
            String json_string = json_object.getString(json_key);
            try {
                object = JSONUtil.getPrimitiveValue(json_string, val_class, catalog_db);
            } catch (Exception ex) {
                System.err.println("val_interfaces: " + val_interfaces);
                LOG.error("Failed to deserialize value '" + json_string + "' from inner map key '" + json_key + "'");
                throw ex;
            }
        }
        map.put(key, object);
    }
}