import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
/**
 * Constructs a proof finder for the given log.
 * 
 * @ensures this.log' = log
 */
NodePruner(TranslationLog log) {
	visited = new IdentityHashSet<Node>();
	relevant = new IdentityHashSet<Node>();

	final RecordFilter filter = new RecordFilter() {
		public boolean accept(Node node, Formula translated, int literal, Map<Variable,TupleSet> env) {
			return env.isEmpty();
		}
	};

	constNodes = new LinkedHashMap<Formula,Boolean>();
	for (Iterator<TranslationRecord> itr = log.replay(filter); itr.hasNext();) {
		TranslationRecord rec = itr.next();
		int lit = rec.literal();
		if (Math.abs(lit) != Integer.MAX_VALUE) {
			constNodes.remove(rec.translated());
		} else if (lit == Integer.MAX_VALUE) {
			constNodes.put(rec.translated(), Boolean.TRUE);
		} else {
			constNodes.put(rec.translated(), Boolean.FALSE);
		}
	}
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
/**
 * Constructs a proof finder for the given log.
 * @ensures this.log' = log
 */
NodePruner(TranslationLog log) {
	visited = new IdentityHashSet<Node>();
	relevant = new IdentityHashSet<Node>();
				
	final RecordFilter filter = new RecordFilter() {
		public boolean accept(Node node, Formula translated, int literal, Map<Variable, TupleSet> env) {
			return env.isEmpty();
		}	
	};
	
	constNodes = new LinkedHashMap<Formula,Boolean>();
	for(Iterator<TranslationRecord> itr = log.replay(filter); itr.hasNext(); ) { 
		TranslationRecord rec = itr.next();
		int lit = rec.literal();
		if (Math.abs(lit) != Integer.MAX_VALUE) { 
			constNodes.remove(rec.translated());
		} else if (lit==Integer.MAX_VALUE) { 
			constNodes.put(rec.translated(), Boolean.TRUE);
		} else {
			constNodes.put(rec.translated(), Boolean.FALSE);
		}
	}
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
public void restoreJavaHeap() {
    ForgeScene forgeScene = fconv.forgeScene();
    for (GlobalVariable mod : modifiable) {
        ObjTupleSet fldVal = eval.evaluate(mod);
        IdentityHashSet<Object> visited = new IdentityHashSet<Object>();
        if (fldVal.isEmpty()) {
            restoreEmpty(mod);
            continue;
        }
        for (ObjTuple ot : fldVal.tuples()) {
            Object obj = ot.get(0);
            if (obj == null)
                continue;
            if (!visited.add(obj))
                continue;
            JField jf = getJFieldForVar(forgeScene, mod);
            FieldValue fv = new FieldValue(jf, mod.arity());
            ObjTupleSet objFldVal = ObjTupleSet.filter(fldVal, 0, obj);
            fv.addAllTuples(objFldVal);
            ObjSerFactory.factory.getSerForObj(obj).concrFunc(obj, fv);
        }
    }
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
private static void printObj(Object obj, StringBuilder sb, String indent, IdentityHashSet<Object> visited) {
        if (obj == null) {
            sb.append("null");
            return;
        }
        Class<? extends Object> cls = obj.getClass();
        if (cls == String.class || Utils.isPrimitive(cls)) {
            sb.append(obj.toString());
            return;
        }
        if (!visited.add(obj)) {
//            sb.append(obj.getClass().getName() + "@" + System.identityHashCode(obj));
            sb.append(obj.getClass().getName());
            return;
        }
//      sb.append(obj.getClass().getName() + "@" + System.identityHashCode(obj));
        sb.append(obj.getClass().getName());
        sb.append("\n");
        indent = indent + tab;
        for (Field f : getAllFields(cls)) {
            sb.append(indent).append(f.getName()).append(": ");
            printObj(getFieldValue(obj, f), sb, indent, visited);
            sb.append(";\n");
        }
    }
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
/**
 * Returns the connected core based on the given set of core variables.
 * 
 * @requires coreVar = StrategyUtils.coreVars(solver.proof());
 * @return let formulas = (this.log.records[int] & literal.{i: int | abs(i)
 *         in coreVars}).formula | connected = {f: formulas | some s: set
 *         coreNodes | f + this.log.formula in s and (s -
 *         this.log.formula).~components in s }
 */
private Set<Formula> connectedCore(final IntSet coreVars) {
	final Set<Formula> coreNodes = new IdentityHashSet<Formula>();
	final RecordFilter filter = new RecordFilter() {
		public boolean accept(Node node, Formula translated, int literal, Map<Variable,TupleSet> env) {
			return coreVars.contains(StrictMath.abs(literal));
		}
	};
	for (Iterator<TranslationRecord> itr = log().replay(filter); itr.hasNext();) {
		coreNodes.add(itr.next().translated());
	}
	final Set<Formula> connected = new IdentityHashSet<Formula>();
	final AbstractVoidVisitor traverser = new AbstractVoidVisitor() {
		final Set<Node> visited = new IdentityHashSet<Node>();

		/**
		 * Returns true if the given node has been visited before or if it
		 * is not contained in this.nodes set. Otherwise adds the node to
		 * the connected set and returns false.
		 * 
		 * @ensures this.visited' = this.visited + n
		 * @ensures n !in this.visited && n in coreNodes => connected' =
		 *          connected + n else connected' = connected
		 * @return n in visited || n !in coreNodes
		 */
		protected boolean visited(Node n) {
			if (visited.add(n) && coreNodes.contains(n)) {
				connected.add((Formula) n);
				return false;
			}
			return true;
		}
	};
	for (Formula root : log().roots()) {
		root.accept(traverser);
	}
	return connected;
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的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.util.collections.IdentityHashSet; //导入依赖的package包/类
public final Set<Relation> atomRelations() {
	final Set<Relation> ans = new IdentityHashSet<Relation>();
	for (Relation r : relations())
		if (r.isAtom())
			ans.add(r);
	return ans;
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
public final Set<Relation> skolemRelations() {
	final Set<Relation> ans = new IdentityHashSet<Relation>();
	for (Relation r : relations())
		if (r.isSkolem())
			ans.add(r);
	return ans;
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
/**
 * Returns the shared internal nodes of this.node. This method should be
 * called only after this visitor has been applied to this.node.
 * 
 * @return {n: Node | #(n.~children & node.*children) > 1 }
 */
IdentityHashSet<Node> sharedNodes() {
	final IdentityHashSet<Node> shared = new IdentityHashSet<Node>(numSharedNodes);
	for (Map.Entry<Node,Boolean> entry : sharingStatus.entrySet()) {
		if (entry.getValue() == Boolean.TRUE)
			shared.add(entry.getKey());
	}
	return shared;
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
/**
 * Constructs a new collector.
 * 
 * @ensures this.negated' = false
 */
PredicateCollector(Set<Node> sharedNodes) {
	this.sharedNodes = sharedNodes;
	this.visited = new IdentityHashMap<Node,Boolean>();
	this.negated = false;
	preds = new EnumMap<RelationPredicate.Name,Set<RelationPredicate>>(RelationPredicate.Name.class);
	preds.put(ACYCLIC, new IdentityHashSet<RelationPredicate>(4));
	preds.put(TOTAL_ORDERING, new IdentityHashSet<RelationPredicate>(4));
	preds.put(FUNCTION, new IdentityHashSet<RelationPredicate>(8));
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
private Set<Node> reduce(Formula formula, int granularity) {
	solver.options().setCoreGranularity(granularity);
	final Solution sol = solver.solve(formula, bounds);
	assertEquals(Solution.Outcome.TRIVIALLY_UNSATISFIABLE, sol.outcome());
	sol.proof().minimize(null);
	return new IdentityHashSet<Node>(sol.proof().highLevelCore().values());

}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
private Set<Node> core(Formula formula, int granularity) {
	solver.options().setCoreGranularity(granularity);
	final Solution sol = solver.solve(formula, bounds);
	assertEquals(Solution.Outcome.UNSATISFIABLE, sol.outcome());
	sol.proof().minimize(new NCEStrategy(sol.proof().log()));
	return new IdentityHashSet<Node>(sol.proof().highLevelCore().values());

}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
/**
 * Returns the connected core based on the given set of 
 * core variables.  
 * @requires coreVar = StrategyUtils.coreVars(solver.proof());
 * @return let formulas = (this.log.records[int] & literal.{i: int | abs(i) in coreVars}).formula |
 *  	   connected = {f: formulas  | some s: set coreNodes | f + this.log.formula in s and (s - this.log.formula).~components in s } 
 */
private Set<Formula>  connectedCore(final IntSet coreVars) {
	final Set<Formula> coreNodes = new IdentityHashSet<Formula>();
	final RecordFilter filter = new RecordFilter() {
		public boolean accept(Node node, Formula translated, int literal, Map<Variable,TupleSet> env) {
			return coreVars.contains(StrictMath.abs(literal));
		}
	};
	for(Iterator<TranslationRecord> itr = log().replay(filter); itr.hasNext(); ) {
		coreNodes.add(itr.next().translated());
	}
	final Set<Formula> connected = new IdentityHashSet<Formula>();
	final AbstractVoidVisitor traverser = new AbstractVoidVisitor() {
		final Set<Node> visited = new IdentityHashSet<Node>();
		/**
		 * Returns true if the given node has been visited before or if 
		 * it is not contained in this.nodes set.  Otherwise adds 
		 * the node to the connected set and returns false.
		 * @ensures this.visited' = this.visited + n
		 * @ensures n !in this.visited && n in coreNodes => 
		 *  connected' = connected + n else connected' = connected
		 * @return n in visited || n !in coreNodes
		 */
		protected boolean visited(Node n) {
			if (visited.add(n) && coreNodes.contains(n)) {
				connected.add((Formula)n);
				return false;
			}
			return true;
		}
	};
	for(Formula root: log().roots()) {
		root.accept(traverser);
	}
	return connected;
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的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.util.collections.IdentityHashSet; //导入依赖的package包/类
/**
 * Returns the shared internal nodes of this.node.  This method should
 * be called only after this visitor has been applied to this.node.
 * @return {n: Node | #(n.~children & node.*children) > 1 }
 */
IdentityHashSet<Node> sharedNodes() {
	final IdentityHashSet<Node> shared = new IdentityHashSet<Node>(numSharedNodes);
	for(Map.Entry<Node,Boolean> entry : sharingStatus.entrySet()) {
		if (entry.getValue()==Boolean.TRUE)
			shared.add(entry.getKey());
	}
	return shared;
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
/**
 * Constructs a new collector.
 * @ensures this.negated' = false
 */
PredicateCollector(Set<Node> sharedNodes) {
	this.sharedNodes = sharedNodes;
	this.visited = new IdentityHashMap<Node,Boolean>();
	this.negated = false;
	preds = new EnumMap<RelationPredicate.Name, Set<RelationPredicate>>(RelationPredicate.Name.class);	
	preds.put(ACYCLIC, new IdentityHashSet<RelationPredicate>(4));
	preds.put(TOTAL_ORDERING, new IdentityHashSet<RelationPredicate>(4));
	preds.put(FUNCTION, new IdentityHashSet<RelationPredicate>(8));
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的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.util.collections.IdentityHashSet; //导入依赖的package包/类
private Set<Node> reduce(Formula formula, int granularity) {
	solver.options().setCoreGranularity(granularity);
	final Solution sol = solver.solve(formula, bounds);
	assertEquals(Solution.Outcome.TRIVIALLY_UNSATISFIABLE, sol.outcome());
	sol.proof().minimize(null);
	return new IdentityHashSet<Node>(sol.proof().highLevelCore().values());
	
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
private Set<Node> core(Formula formula, int granularity) {
	solver.options().setCoreGranularity(granularity);
	final Solution sol = solver.solve(formula, bounds);
	assertEquals(Solution.Outcome.UNSATISFIABLE, sol.outcome());
	sol.proof().minimize(new NCEStrategy(sol.proof().log()));
	return new IdentityHashSet<Node>(sol.proof().highLevelCore().values());
	
}
 

import kodkod.util.collections.IdentityHashSet; //导入依赖的package包/类
private Set<Object> myObjectsForClass(Class<?> cls)   {
    Set<Object> ret = world.get(cls);
    if (ret == null) {
        ret = new IdentityHashSet<Object>();
        world.put(cls, ret); 
    }
    return ret;
}