Java OrderedHashSet类代码示例

import org.antlr.v4.runtime.misc.OrderedHashSet; //导入依赖的package包/类
/** DFS-based topological sort.  A valid sort is the reverse of
 *  the post-order DFA traversal.  Amazingly simple but true.
 *  For sorting, I'm not following convention here since ANTLR
 *  needs the opposite.  Here's what I assume for sorting:
 *
 *    If there exists an edge u -> v then u depends on v and v
 *    must happen before u.
 *
 *  So if this gives nonreversed postorder traversal, I get the order
 *  I want.
 */
public List<T> sort() {
	Set<Node<T>> visited = new OrderedHashSet<Node<T>>();
	ArrayList<T> sorted = new ArrayList<T>();
	while ( visited.size() < nodes.size() ) {
		// pick any unvisited node, n
		Node<T> n = null;
		for (Node<T> tNode : nodes.values()) {
			n = tNode;
			if ( !visited.contains(n) ) break;
		}
		if (n!=null) { // if at least one unvisited
			DFS(n, visited, sorted);
		}
	}
	return sorted;
}
 

import org.antlr.v4.runtime.misc.OrderedHashSet; //导入依赖的package包/类
/** enclosingRule calls targetRule. Find the cycle containing
 *  the target and add the caller.  Find the cycle containing the caller
 *  and add the target.  If no cycles contain either, then create a new
 *  cycle.
 */
protected void addRulesToCycle(Rule enclosingRule, Rule targetRule) {
	//System.err.println("left-recursion to "+targetRule.name+" from "+enclosingRule.name);
	boolean foundCycle = false;
	for (Set<Rule> rulesInCycle : listOfRecursiveCycles) {
		// ensure both rules are in same cycle
		if (rulesInCycle.contains(targetRule)) {
			rulesInCycle.add(enclosingRule);
			foundCycle = true;
		}
		if (rulesInCycle.contains(enclosingRule)) {
			rulesInCycle.add(targetRule);
			foundCycle = true;
		}
	}
	if ( !foundCycle ) {
		Set<Rule> cycle = new OrderedHashSet<Rule>();
		cycle.add(targetRule);
		cycle.add(enclosingRule);
		listOfRecursiveCycles.add(cycle);
	}
}
 

import org.antlr.v4.runtime.misc.OrderedHashSet; //导入依赖的package包/类
/**
 * Subscribes given component to given identifier. If there are no subscriptions
 * yet for this identifier, an entry in the subscriptions map is created.
 *
 * @param formComponent the component to subscribe.
 * @param identifier    the identifier the given component should be
 *                      subscribed to.
 */
private void subscribeComponentToIdentifier(AbstractFormComponent formComponent,
                                            String identifier) {
    if (hasSubscriptionsForIdentifier(identifier)) {
        subscriptions.get(identifier).add(formComponent);
    } else {
        HashSet<AbstractFormComponent> subscribedComponents =
                new OrderedHashSet<AbstractFormComponent>();
        subscribedComponents.add(formComponent);
        subscriptions.put(identifier, subscribedComponents);
    }
}
 

import org.antlr.v4.runtime.misc.OrderedHashSet; //导入依赖的package包/类
private FormFrameBuilder(Form form, GUIController controller) {
    formComponents = new OrderedHashSet<AbstractFormComponent>();
    EvaluationVisitor evaluator = new EvaluationVisitor();
    FormEventManager eventManager = new FormEventManager(evaluator);
    formFrame = new FormFrame(form.getName(), evaluator, eventManager);
    AbstractFormComponent topComponent = form.getBody().accept(this);
    initValues();
    formFrame.initUI(topComponent, controller);
}
 

import org.antlr.v4.runtime.misc.OrderedHashSet; //导入依赖的package包/类
/** Add local var decl */
public void addLocalDecl(Decl d) {
	if ( locals ==null ) locals = new OrderedHashSet<Decl>();
	locals.add(d);
	d.isLocal = true;
}
 

import org.antlr.v4.runtime.misc.OrderedHashSet; //导入依赖的package包/类
/** Add local var decl */
public void addLocalDecl(Decl d) {
	if ( locals==null ) locals = new OrderedHashSet<Decl>();
	locals.add(d);
	d.isLocal = true;
}