import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/**
 * Calls lookup(intExpr) and returns the cached value, if any. If a
 * translation has not been cached, translates the expression, calls
 * cache(...) on it and returns it.
 * 
 * @return let t = lookup(intExpr) | some t => t, cache(intExpr,
 *         intExpr.op(intExpr.expression.accept(this)))
 */
public final Int visit(UnaryIntExpression intExpr) {
	Int ret = lookup(intExpr);
	if (ret != null)
		return ret;
	final Int child = intExpr.intExpr().accept(this);
	switch (intExpr.op()) {
		case NEG :
			ret = child.negate();
			break;
		case NOT :
			ret = child.not();
			break;
		case ABS :
			ret = child.abs();
			break;
		case SGN :
			ret = child.sgn();
			break;
		default :
			throw new IllegalArgumentException("Unknown operator: " + intExpr.op());
	}
	return cache(intExpr, ret);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/** {@inheritDoc} */
public void visit(UnaryIntExpression x) {
	String newname = makename(x);
	if (newname == null)
		return;
	String sub = make(x.intExpr());
	switch (x.op()) {
		case MINUS :
			file.printf("IntExpression %s=%s.negate();%n", newname, sub);
			break;
		case NOT :
			file.printf("IntExpression %s=%s.not();%n", newname, sub);
			break;
		case ABS :
			file.printf("IntExpression %s=%s.abs();%n", newname, sub);
			break;
		case SGN :
			file.printf("IntExpression %s=%s.signum();%n", newname, sub);
			break;
		default :
			throw new RuntimeException("Unknown kodkod operator \"" + x.op() + "\" encountered");
	}
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
public IntExpression visit(UnaryIntExpression expr) { 
	IntExpression ret = lookup(expr);
	if (ret!=null) return ret;
	
	final IntOperator op = expr.op();
	final IntExpression child = expr.intExpr().accept(this);
	
	ret = simplify(op, child);
	if (ret==null) {
		final int hash = hash(op, child);
		for(Iterator<PartialCannonicalizer.Holder<IntExpression>> itr = intExprs.get(hash); itr.hasNext(); ) {
			final IntExpression next = itr.next().obj;
			if (next.getClass()==UnaryIntExpression.class) { 
				if (((UnaryIntExpression)next).intExpr()==child)
					return cache(expr, next);
			}
		}
		ret = child==expr.intExpr() ? expr : child.apply(op);
		intExprs.add(new PartialCannonicalizer.Holder<IntExpression>(ret, hash));
	}
	return cache(expr,ret);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/**
 * Calls lookup(intExpr) and returns the cached value, if any. If a
 * replacement has not been cached, visits the expression's child. If
 * nothing changes, the argument is cached and returned, otherwise a
 * replacement expression is cached and returned.
 * 
 * @return { u: UnaryIntExpression | u.expression =
 *         intExpr.expression.accept(delegate) && u.op = intExpr.op }
 */
public IntExpression visit(UnaryIntExpression intExpr) {
	IntExpression ret = lookup(intExpr);
	if (ret != null)
		return ret;

	final IntExpression child = intExpr.intExpr().accept(delegate);
	ret = (child == intExpr.intExpr()) ? intExpr : child.apply(intExpr.op());
	return cache(intExpr, ret);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/**
 * Calls lookup(intExpr) and returns the cached value, if any. If no cached
 * value exists, visits the child, caches its return value and returns it.
 * 
 * @return let x = lookup(intExpr) | x != null => x, cache(intExpr,
 *         intExpr.expression.accept(this))
 */
public Set<T> visit(UnaryIntExpression intExpr) {
	Set<T> ret = lookup(intExpr);
	if (ret != null)
		return ret;
	ret = newSet();
	ret.addAll(intExpr.intExpr().accept(this));
	return cache(intExpr, ret);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/**
 * @ensures appends the given op and child to this.tokens; the child is
 *          parenthesized if it's not an instance of unary int
 *          expression or int constant.
 **/
public void visit(UnaryIntExpression node) {
	final IntExpression child = node.intExpr();
	final IntOperator op = node.op();
	final boolean parens = (op == IntOperator.ABS) || (op == IntOperator.SGN) || parenthesize(child);
	append(node.op());
	visitChild(child, parens);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/** {@inheritDoc} */
public void visit(UnaryIntExpression x) {
    String newname=makename(x); if (newname==null) return;
    String sub=make(x.intExpr());
    switch(x.op()) {
       case MINUS: file.printf("IntExpression %s=%s.negate();%n", newname, sub); break;
       case NOT: file.printf("IntExpression %s=%s.not();%n", newname, sub); break;
       case ABS: file.printf("IntExpression %s=%s.abs();%n", newname, sub); break;
       case SGN: file.printf("IntExpression %s=%s.signum();%n", newname, sub); break;
       default: throw new RuntimeException("Unknown kodkod operator \""+x.op()+"\" encountered");
    }
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/** 
 * Calls lookup(intExpr) and returns the cached value, if any.  
 * If a replacement has not been cached, visits the expression's 
 * child.  If nothing changes, the argument is cached and
 * returned, otherwise a replacement expression is cached and returned.
 * @return { u: UnaryIntExpression | u.expression = intExpr.expression.accept(this) && u.op = intExpr.op }
 */
public IntExpression visit(UnaryIntExpression intExpr) {
	IntExpression ret = lookup(intExpr);
	if (ret!=null) return ret;

	final IntExpression child = intExpr.intExpr().accept(this);
	ret = (child==intExpr.intExpr()) ?  intExpr : child.apply(intExpr.op());
	return cache(intExpr,ret);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/** 
 * Calls lookup(intExpr) and returns the cached value, if any.  
 * If no cached value exists, visits the child, caches its return value and returns it. 
 * @return let x = lookup(intExpr) | 
 *          x != null => x,  
 *          cache(intExpr, intExpr.expression.accept(this)) 
 */
public Set<T> visit(UnaryIntExpression intExpr) {
	Set<T> ret = lookup(intExpr);
	if (ret!=null) return ret;
	ret = newSet();
	ret.addAll(intExpr.intExpr().accept(this));
	return cache(intExpr,ret);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/** 
 * Calls lookup(intExpr) and returns the cached value, if any.  
 * If a translation has not been cached, translates the expression,
 * calls cache(...) on it and returns it.
 * @return let t = lookup(intExpr) | some t => t, 
 * 	cache(intExpr, intExpr.op(intExpr.expression.accept(this)))
 */
public final Int visit(UnaryIntExpression intExpr) {
	Int ret = lookup(intExpr);
	if (ret!=null) return ret;
	final Int child = intExpr.intExpr().accept(this);
	switch(intExpr.op()) {
	case NEG 	: ret = child.negate(); break;
	case NOT 	: ret = child.not(); break;
	case ABS 	: ret = child.abs(); break;
	case SGN 	: ret = child.sgn(); break;
	default : 
		throw new IllegalArgumentException("Unknown operator: " + intExpr.op());
	}
	return cache(intExpr, ret);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/** @ensures appends the given op and child to this.tokens; the child is 
 * parenthesized if it's not an instance of unary int expression or int constant. **/
public void visit(UnaryIntExpression node)  { 
	final IntExpression child = node.intExpr();
	final IntOperator op = node.op();
	final boolean parens = 
		(op==IntOperator.ABS) || (op==IntOperator.SGN) || 
		parenthesize(child);
	append(node.op());
	visitChild(child, parens);
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/** @effects appends the given op and child to this.tokens; the child is 
 * parenthesized if it's not an instance of unary int expression or int constant. **/
public void visit(UnaryIntExpression node)  { 
	if (displayed(node)) return;
	final boolean oldTop = notTop();
	final IntExpression child = node.intExpr();
	final IntOperator op = node.op();
	final boolean parens = 
		(op==IntOperator.ABS) || (op==IntOperator.SGN) || 
		parenthesize(child);
	append(node.op());
	visitChild(child, parens);
	top = oldTop;
}
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
public IntExpression visit(UnaryIntExpression expr) { 
	IntExpression ret = lookup(expr);
	if (ret!=null) return ret;
	
	final IntOperator op = expr.op();
	final IntExpression child = expr.intExpr().accept(this);
	
	ret = simplify(op, child);
	if (ret==null) {
		ret = child==expr.intExpr() ? expr : child.apply(op);
	}
	return cache(expr,ret);
}
 

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

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
@Override
public IntExpression visit(UnaryIntExpression intExpr) {
	return intExpr;
}
 

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

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
public Boolean visit(UnaryIntExpression e) {
	return checkVisitedThenAccumA(e, Boolean.FALSE, e.intExpr());
}
 

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

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/**
 * Visits the given unary integer expression.
 */
public void visit(UnaryIntExpression intExpr);
 

import kodkod.ast.UnaryIntExpression; //导入依赖的package包/类
/**
 * Visits the subexpression if this.visited(intExpr) returns false.
 * Otherwise does nothing.
 * 
 * @ensures unaryExpr.expression.accept(this)
 */
public void visit(UnaryIntExpression intExpr) {
	if (visited(intExpr))
		return;
	intExpr.intExpr().accept(this);
}