kodkod.ast.ProjectExpression Java Examples

/** @effects appends the tokenization of the given node to this.tokens */
public void visit(ProjectExpression node) {
	if (displayed(node)) return;
	final boolean oldTop = notTop();
	append("project");
	append("[");
	node.expression().accept(this);
	comma();
	append("<");
	final Iterator<IntExpression> cols = node.columns();
	cols.next().accept(this);
	while(cols.hasNext()) { 
		comma();
		cols.next().accept(this);
	}
	append(">");
	append("]");
	top = oldTop;
}
 

/**
 * Calls lookup(decls) and returns the cached value, if any. If a replacement
 * has not been cached, visits each of the children's variable and expression.
 * If nothing changes, the argument is cached and returned, otherwise a
 * replacement Decls object is cached and returned.
 *
 * @return { d: Decls | d.size = decls.size && all i: [0..d.size) |
 *         d.declarations[i] = decls.declarations[i].accept(delegate) }
 */
@Override
public Expression visit(ProjectExpression project) {
    Expression ret = lookup(project);
    if (ret != null)
        return ret;

    final Expression expr = project.expression().accept(delegate);
    final IntExpression[] cols = new IntExpression[project.arity()];
    boolean allSame = expr == project.expression();
    for (int i = 0, arity = project.arity(); i < arity; i++) {
        cols[i] = project.column(i).accept(delegate);
        allSame = allSame && (cols[i] == project.column(i));
    }
    ret = allSame ? project : expr.project(cols);
    return cache(project, ret);
}
 

/** @ensures appends the tokenization of the given node to this.tokens */
public void visit(ProjectExpression node) {
	append("project");
	append("[");
	node.expression().accept(this);
	comma();
	append("<");
	final Iterator<IntExpression> cols = node.columns();
	cols.next().accept(this);
	while(cols.hasNext()) { 
		comma();
		cols.next().accept(this);
	}
	append(">");
	append("]");
}
 

/**
 * @ensures appends the tokenization of the given node to this.tokens
 */
@Override
public void visit(ProjectExpression node) {
    append("project");
    append("[");
    node.expression().accept(this);
    comma();
    append("<");
    final Iterator<IntExpression> cols = node.columns();
    cols.next().accept(this);
    while (cols.hasNext()) {
        comma();
        cols.next().accept(this);
    }
    append(">");
    append("]");
}
 

/** {@inheritDoc} */
@Override
public void visit(ProjectExpression x) {
    String newname = makename(x);
    if (newname == null)
        return;
    String expr = make(x.expression());
    List<String> names = new ArrayList<String>();
    for (Iterator<IntExpression> i = x.columns(); i.hasNext();) {
        names.add(make(i.next()));
    }
    for (int i = 0; i < names.size(); i++) {
        if (i == 0)
            file.printf("Expression %s=%s.project(", newname, expr);
        else
            file.printf(",");
        file.printf("%s", names.get(i));
    }
    file.printf(");%n");
}
 

@Override
public Boolean visit(ProjectExpression project) {
    Boolean ans = get(project);
    if (ans != null)
        return ans;
    List<IntExpression> cols = new ArrayList<IntExpression>(project.arity());
    for (int i = 0, arity = project.arity(); i < arity; i++) {
        cols.add(project.column(i));
    }
    return accum(project, project.expression().accept(this), cols);
}
 

/**
 * Calls lookup(project) 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(project) | some t => t, 
 * 			cache(project, project.expression.accept(this).project(translate(project.columns))
 */
public final BooleanMatrix visit(ProjectExpression project) {
	BooleanMatrix ret = lookup(project);
	if (ret!=null) return ret;

	final Int[] cols = new Int[project.arity()];
	for(int i = 0, arity = project.arity(); i < arity; i++) {
		cols[i] = project.column(i).accept(this);
	}

	return cache(project, project.expression().accept(this).project(cols));
}
 

/**
 * Calls lookup(project) and returns the cached value, if any.  If no cached
 * value exists, visits each child, caches the disjunction of the children's return
 * values and returns it.
 * @return let x = lookup(project) | 
 *          x != null => x,  
 *          cache(project, project.expression.accept(this) || project.columns[int].accept(this)) 
 */
public Boolean visit(ProjectExpression project) {
	final Boolean ret = lookup(project);
	if (ret!=null) return ret;
	if (project.expression().accept(this))
		return cache(project, true);
	for(int i = 0, arity = project.arity(); i < arity; i++) {
		if (project.column(i).accept(this))
			return cache(project, true);
	}
	return cache(project, false);
}
 

/**
 * Calls lookup(project) and returns the cached value, if any.  If no cached
 * value exists, visits each child, caches the union of the children's return
 * values and returns it.
 * @return let x = lookup(project) | 
 *          x != null => x,  
 *          cache(project, project.expression.accept(this) + project.columns[int].accept(this)) 
 */
public Set<T> visit(ProjectExpression project) {
	Set<T> ret = lookup(project);
	if (ret!=null) return ret;
	ret = newSet();
	ret.addAll(project.expression().accept(this));
	for(int i = 0, arity = project.arity(); i < arity; i++) {
		ret.addAll(project.column(i).accept(this));
	}
	return cache(project,ret);
}
 

/**
 * Visits project.expression and project.columns if this.visited(project) returns false.
 * Otherwise does nothing.
 * @ensures project.expression.accept(this) && all i: project.arity | project.columns[i].accept(this)
 */
public void visit(ProjectExpression project) {
	if (visited(project)) return;
	project.expression().accept(this);
	for(int i = 0, arity = project.arity(); i < arity; i++) {
		project.column(i).accept(this);
	}
}
 

/** 
 * Calls lookup(decls) and returns the cached value, if any.  
 * If a replacement has not been cached, visits each of the children's 
 * variable and expression.  If nothing changes, the argument is cached and
 * returned, otherwise a replacement Decls object is cached and returned.
 * @return { d: Decls | d.size = decls.size && 
 *                      all i: [0..d.size) | d.declarations[i] = decls.declarations[i].accept(this) } 
 */
public Expression visit(ProjectExpression project) { 
	Expression ret = lookup(project);
	if (ret!=null) return ret;

	final Expression expr = project.expression().accept(this);
	final IntExpression[] cols = new IntExpression[project.arity()];
	boolean allSame = expr==project.expression();
	for(int i = 0, arity = project.arity(); i < arity; i++) {
		cols[i] = project.column(i).accept(this);
		allSame = allSame && (cols[i]==project.column(i));
	}
	ret = allSame ? project : expr.project(cols);
	return cache(project, ret);
}
 

/**
 * Calls lookup(project) 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(project) | some t => t, cache(project,
 *         project.expression.accept(this).project(translate(project.columns))
 */
@Override
public final BooleanMatrix visit(ProjectExpression project) {
    BooleanMatrix ret = lookup(project);
    if (ret != null)
        return ret;

    final Int[] cols = new Int[project.arity()];
    for (int i = 0, arity = project.arity(); i < arity; i++) {
        cols[i] = project.column(i).accept(this);
    }

    return cache(project, project.expression().accept(this).project(cols));
}
 

/**
 * Calls lookup(project) and returns the cached value, if any. If no cached
 * value exists, visits each child, caches the disjunction of the children's
 * return values and returns it.
 *
 * @return let x = lookup(project) | x != null => x, cache(project,
 *         project.expression.accept(this) || project.columns[int].accept(this))
 */
@Override
public Boolean visit(ProjectExpression project) {
    final Boolean ret = lookup(project);
    if (ret != null)
        return ret;
    if (project.expression().accept(this))
        return cache(project, true);
    for (int i = 0, arity = project.arity(); i < arity; i++) {
        if (project.column(i).accept(this))
            return cache(project, true);
    }
    return cache(project, false);
}
 

/**
 * Calls lookup(project) and returns the cached value, if any. If no cached
 * value exists, visits each child, caches the union of the children's return
 * values and returns it.
 *
 * @return let x = lookup(project) | x != null => x, cache(project,
 *         project.expression.accept(this) + project.columns[int].accept(this))
 */
@Override
public Set<T> visit(ProjectExpression project) {
    Set<T> ret = lookup(project);
    if (ret != null)
        return ret;
    ret = newSet();
    ret.addAll(project.expression().accept(this));
    for (int i = 0, arity = project.arity(); i < arity; i++) {
        ret.addAll(project.column(i).accept(this));
    }
    return cache(project, ret);
}
 

/**
 * Visits project.expression and project.columns if this.visited(project)
 * returns false. Otherwise does nothing.
 *
 * @ensures project.expression.accept(this) && all i: project.arity |
 *          project.columns[i].accept(this)
 */
@Override
public void visit(ProjectExpression project) {
    if (visited(project))
        return;
    project.expression().accept(this);
    for (int i = 0, arity = project.arity(); i < arity; i++) {
        project.column(i).accept(this);
    }
}
 

@Override
public E visit(ProjectExpression project) {
    start(project);
    return end(project, visitor.visit(project));
}
 

@Override
public void visit(ProjectExpression project) {
    visit(project, "proj", project.expression(), project.columns());
}
 

@Override
public Expression visit(ProjectExpression project) {
    return project;
}
 

public void visit(ProjectExpression project) {
	visit(project, "proj", project.expression(), project.columns());
}
 

/**
 * Visits the given projection expression.
 */
public void visit(ProjectExpression project);
 

/**
 * Visits the given projection expression and returns the result.
 * @return the result of visiting <code>project</code>
 */
public E visit(ProjectExpression project);
 

/**
 * Visits the given projection expression and returns the result.
 *
 * @return the result of visiting <code>project</code>
 */
public E visit(ProjectExpression project);
 

/**
 * Visits the given projection expression.
 */
public void visit(ProjectExpression project);