import kodkod.ast.visitor.VoidVisitor; //导入依赖的package包/类
/**
 * Returns a minimal subset of {@linkplain #roots(Formula) roots} of the
 * given formula such that all nodes in the given collection are reachable
 * from those roots. The returned subset is a local minimum in that none of
 * its members can be removed without leaving some node in the descendants
 * set unreachable from the remaining roots.
 * 
 * @requires descendants in formula.*components
 * @return { s: Set<Formula> | s.elements in roots(formula) and descendants
 *         in s.elements.*components and no s': Set<Formula> |
 *         s.containsAll(s') and s'.size()<s.size() and descendants in
 *         s.elements.*components }
 * @throws IllegalArgumentException descendants !in formula.*components
 */
public static Set<Formula> minRoots(Formula formula, Collection< ? extends Node> descendants) {

	final Set<Node> desc = new IdentityHashSet<Node>(descendants);
	final VoidVisitor visitor = new AbstractVoidVisitor() {
		final Set<Node> visited = new IdentityHashSet<Node>();

		@Override
		protected boolean visited(Node n) {
			if (visited.add(n)) {
				desc.remove(n);
				return false;
			}
			return true;
		}
	};

	final Set<Formula> roots = new LinkedHashSet<Formula>();
	for (Formula root : roots(formula)) {
		final int size = desc.size();
		root.accept(visitor);
		if (desc.size() < size) {
			roots.add(root);
		}
		if (desc.isEmpty()) {
			break;
		}
	}

	if (!desc.isEmpty())
		throw new IllegalArgumentException(
				"descendants !in formula.*components: formula=" + formula + " ; descendants=" + descendants);

	return roots;
}
 

import kodkod.ast.visitor.VoidVisitor; //导入依赖的package包/类
/**
 * Returns a minimal subset of {@linkplain #roots(Formula) roots} of the given formula such that all nodes in the given collection
 * are reachable from those roots.  The returned subset is a local minimum in that none of its members can be removed without leaving
 * some node in the descendants set unreachable from the remaining roots.
 * @requires descendants in formula.*components
 * @return { s: Set<Formula> | s.elements in roots(formula) and descendants in s.elements.*components and 
 * 				no s': Set<Formula> | s.containsAll(s') and s'.size()<s.size() and descendants in s.elements.*components }
 * @throws IllegalArgumentException - descendants !in formula.*components
 */
public static Set<Formula> minRoots(Formula formula, Collection<? extends Node> descendants) { 
	
	final Set<Node> desc = new IdentityHashSet<Node>(descendants);
	final VoidVisitor visitor = new AbstractVoidVisitor() {
		final Set<Node> visited = new IdentityHashSet<Node>();
		@Override
		protected boolean visited(Node n) {
			if (visited.add(n)) {
				desc.remove(n);
				return false;
			}
			return true;
		}
	};
	
	final Set<Formula> roots = new LinkedHashSet<Formula>();
	for(Formula root : roots(formula)) { 
		final int size = desc.size();
		root.accept(visitor);
		if (desc.size()<size) { roots.add(root); }
		if (desc.isEmpty()) { break; }
	}
	
	if (!desc.isEmpty()) 
		throw new IllegalArgumentException("descendants !in formula.*components: formula="+formula+" ; descendants="+descendants);
	
	return roots;
}
 

import kodkod.ast.visitor.VoidVisitor; //导入依赖的package包/类
/**
 * Returns a minimal subset of {@linkplain #roots(Formula) roots} of the given formula such that all nodes in the given collection
 * are reachable from those roots.  The returned subset is a local minimum in that none of its members can be removed without leaving
 * some node in the descendants set unreachable from the remaining roots.
 * @requires descendants in formula.*components
 * @return { s: Set<Formula> | s.elements in roots(formula) and descendants in s.elements.*components and 
 * 				no s': Set<Formula> | s.containsAll(s') and s'.size()<s.size() and descendants in s.elements.*components }
 * @throws IllegalArgumentException  descendants !in formula.*components
 */
public static Set<Formula> minRoots(Formula formula, Collection<? extends Node> descendants) { 
	
	final Set<Node> desc = new IdentityHashSet<Node>(descendants);
	final VoidVisitor visitor = new AbstractVoidVisitor() {
		final Set<Node> visited = new IdentityHashSet<Node>();
		@Override
		protected boolean visited(Node n) {
			if (visited.add(n)) {
				desc.remove(n);
				return false;
			}
			return true;
		}
	};
	
	final Set<Formula> roots = new LinkedHashSet<Formula>();
	for(Formula root : roots(formula)) { 
		final int size = desc.size();
		root.accept(visitor);
		if (desc.size()<size) { roots.add(root); }
		if (desc.isEmpty()) { break; }
	}
	
	if (!desc.isEmpty()) 
		throw new IllegalArgumentException("descendants !in formula.*components: formula="+formula+" ; descendants="+descendants);
	
	return roots;
}
 

import kodkod.ast.visitor.VoidVisitor; //导入依赖的package包/类
@Override
public void accept(VoidVisitor visitor) {
	visitor.visit(this);
}
 

import kodkod.ast.visitor.VoidVisitor; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * @see kodkod.ast.IntExpression#accept(kodkod.ast.visitor.VoidVisitor)
 */
@Override
public void accept(VoidVisitor visitor) {
	visitor.visit(this);
}
 

import kodkod.ast.visitor.VoidVisitor; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * @see kodkod.ast.Node#accept(kodkod.ast.visitor.VoidVisitor)
 */
@Override
public void accept(VoidVisitor visitor) {
	visitor.visit(this);
}
 

import kodkod.ast.visitor.VoidVisitor; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * @see kodkod.ast.Node#accept(kodkod.ast.visitor.VoidVisitor)
 */
@Override
public void accept(VoidVisitor visitor) {
	visitor.visit(this);	
}
 

import kodkod.ast.visitor.VoidVisitor; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see kodkod.ast.Node#accept(kodkod.ast.visitor.VoidVisitor)
 */
public void accept(VoidVisitor visitor) {
	visitor.visit(this);
}