import kodkod.ast.ConstantFormula; //导入依赖的package包/类
private void edge(Node n1, Node n2) {
	if (n2 instanceof LeafExpression || n2 instanceof ConstantFormula || n2 instanceof IntConstant) {

	}
	graph.append(id(n1));
	graph.append("->");
	graph.append(id(n2));
	graph.append(";\n");
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** {@inheritDoc} */
public void visit(ConstantFormula x) {
	if (map.containsKey(x))
		return;
	String newname = (x.booleanValue() ? "Formula.TRUE" : "Formula.FALSE");
	map.put(x, newname);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
private void edge(Node n1, Node n2) { 
	if (n2 instanceof LeafExpression || n2 instanceof ConstantFormula || n2 instanceof IntConstant) {
		
	}
	graph.append(id(n1));
	graph.append("->");
	graph.append(id(n2));
	graph.append(";\n");
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
@Override
public F visit(ConstantFormula constant) {
	start(constant);
	return end(constant, visitor.visit(constant));
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
public void visit(ConstantFormula formula) {
	relevant.add(formula);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** @see #visitFormula(Formula) */
public final void visit(ConstantFormula constant) {
	visitFormula(constant);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
@Override
public Proc visit(ConstantFormula constant) {
	return new Proc.FOL(bounds, constant);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** @ensures this.tokens' = concat[ this.tokens, node ] */
public void visit(ConstantFormula node) {
	append(node);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/**
 * @return true if the given formula should be parenthesized when a
 *         child of a compound parent
 */
private boolean parenthesize(Formula child) {
	return !(child instanceof NotFormula || child instanceof ConstantFormula
			|| child instanceof RelationPredicate);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
public Boolean visit(ConstantFormula cnst) {
	return noHOL(cnst);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** {@inheritDoc} */
public void visit(ConstantFormula x) {
    if (map.containsKey(x)) return;
    String newname=(x.booleanValue() ? "Formula.TRUE" : "Formula.FALSE");
    map.put(x,newname);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/**
 * Returns Collections.EMPTY_SET
 * @return Collections.EMPTY_SET
 */
@SuppressWarnings("unchecked")
public Set<T> visit(ConstantFormula constant) {
	return Collections.EMPTY_SET;
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
public void visit(ConstantFormula formula) { 
	relevant.add(formula);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** @see #visitFormula(Formula) */
public final void visit(ConstantFormula constant)   { visitFormula(constant); }
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
@Override
public Formula visit(ConstantFormula constant) {
    boolean negOld = negated;
    negated = false;
    return addFormula(super.visit(constant), constant, negOld); 
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/**
 * @return constant = ConstantFormula.TRUE => BooleanConstant.TRUE, BooleanConstant.FALSE
 */
public final BooleanValue visit(ConstantFormula constant) {
	return cache(constant, BooleanConstant.constant(constant.booleanValue()));
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** @see #visitFormula(Formula) */
public final void visit(ConstantFormula constant)	{ visitFormula(constant); }
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** @ensures this.tokens' = concat[ this.tokens, node ] */
public void visit(ConstantFormula node) { append(node); }
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** @return true if the given formula should be parenthesized when a 
 * child of a compound parent */
private boolean parenthesize(Formula child) { 
	return !(child instanceof NotFormula || child instanceof ConstantFormula || 
			 child instanceof RelationPredicate);
}
 

import kodkod.ast.ConstantFormula; //导入依赖的package包/类
/** @effects this.tokens' = concat[ this.tokens, node ] */
public void visit(ConstantFormula node) { append(node); }