*
*
* fhom[list,op,id](filter,f) = if isEmpty(list)
* then id
* else let elt = head(list)
* in if filter(elt)
* then op(f(elt),fhom[tail(list),op,id](filter,f))
* else fhom[tail(list),op,id](filter,f)
*
*
*
* This class is defined to enable an optimization of monoid comprehensions where a boolean
* qualifier can be integrated directly into the homomorphism preceding it, thus doing away
* with the generation of a larger set than necessary. When this is used after normalizing
* monoid comprehension with unnesting of conditions to the uppermost scope they control
* together with gathering them into a single logical and, the net effect is a
* drastic reduction of the size of loops. Recall that a monoid comprehension
* is an expression of the form:
*
*
* [op,id] { e | q1, ..., qn }
*
*
* where [op,id] define a monoid, e is an expression, and the
* qi's are qualifiers. A qualifier is either a
* (boolean) expression or a pair x <- e, where x is
* a variable and e is a (collection) expression. After normalization,
* there may be at most one boolean qualifier in the sequence (which may
* also be empty). Such a normalized monoid comprehension can then be translated
* as follows:
* *
*
* [op,id]{e | } = op(e,id);
*
* [op,id]{e | c} = if c then op(e,id) else id;
*
* [op,id]{e | x <- e', c, Q} = f_hom(e', lambda x.[op,id]{e | Q}, op, id, lambda x.c);
*
* [op,id]{e | x <- e', y <- e'', Q} = hom(e', lambda x.[op,id]{e | y <- e'', Q}, op, id);
*
*
*/
public class FilterHomomorphism extends Homomorphism
{
/**
* This is the filtering boolean function applied to each element of the collection.
*/
private Expression _filter;
private Tables _tables;
public FilterHomomorphism (Tables tables, Expression collection, Expression function,
Expression operation, Expression identity, Expression filter)
{
super(collection,function,operation,identity);
_tables = tables;
_filter = filter;
}
private FilterHomomorphism (Tables tables, Expression collection, Expression function,
Expression operation, Expression identity, Expression filter,
byte inPlace)
{
this(tables,collection,function,operation,identity,filter);
_inPlace = inPlace;
}
public final Expression copy ()
{
FilterHomomorphism copy = new FilterHomomorphism(_tables,
_collection.copy(),
_function.copy(),
_operation.copy(),
_identity.copy(),
_filter.copy(),
_inPlace);
if (_slicings != null)
{
Expression[] slicings = new Expression[_slicings.length];
for (int i=slicings.length; i-->0;)
slicings[i] = _slicings[i].copy();
copy.setSlicings(slicings);
}
return copy;
}
public final Expression typedCopy ()
{
FilterHomomorphism copy = new FilterHomomorphism(_tables,
_collection.typedCopy(),
_function.typedCopy(),
_operation.typedCopy(),
_identity.typedCopy(),
_filter.copy(),
_inPlace);
if (_slicings != null)
{
Expression[] slicings = new Expression[_slicings.length];
for (int i=slicings.length; i-->0;)
slicings[i] = _slicings[i].typedCopy();
copy.setSlicings(slicings);
}
return copy.addTypes(this);
}
/**
* Returns the number of subexpressions
*/
public int numberOfSubexpressions ()
{
if (_filter == null)
return super.numberOfSubexpressions();
return super.numberOfSubexpressions() + 1;
}
/**
* Returns the n-th subexpression of this expression; if there is no subexpression
* at the given position, this throws a NoSuchSubexpressionException
*/
public final Expression subexpression (int n) throws NoSuchSubexpressionException
{
if (_filter == null)
return super.subexpression(n);
switch (n)
{
case 0:
return _collection;
case 1:
return _function;
case 2:
return _operation;
case 3:
return _identity;
case 4:
return _filter;
default:
int s = n-5;
if (_slicings != null && s >= 0 && s < _slicings.length)
return _slicings[s];
throw new NoSuchSubexpressionException(this,n);
}
}
public final Expression setSubexpression (int n, Expression expression) throws NoSuchSubexpressionException
{
if (_filter == null)
return super.setSubexpression(n,expression);
switch (n)
{
case 0:
_collection = expression;
break;
case 1:
_function = expression;
break;
case 2:
_operation = expression;
break;
case 3:
_identity = expression;
break;
case 4:
_filter = expression;
break;
default:
int s = n-5;
if (_slicings != null && s >= 0 && s < _slicings.length)
_slicings[s] = expression;
else
throw new NoSuchSubexpressionException(this,n);
}
return this;
}
public final void typeCheck (TypeChecker typeChecker) throws TypingErrorException
{
super.typeCheck(typeChecker);
_filter.typeCheck(new FunctionType(_elementType,Type.BOOLEAN()),typeChecker);
}
public final void setCheckedType ()
{
if (setCheckedTypeLocked()) return;
_extractNewSlicings();
if (_filter != null)
_filter.setCheckedType();
_setCheckedTypeLocked = false;
super.setCheckedType();
}
/**
* This visits the filter after type-checking to look for possible new slicings.
* This is because some opaque types defined as tuple types may use accessor
* applications rather than tuple projections. Identifying such slicings can
* only be done after type-checking.
*/
private final void _extractNewSlicings ()
{
ArrayList filters = new ArrayList();
ArrayList newFilters = new ArrayList();
ArrayList newSlicings = new ArrayList();
Expression filter = ((Scope)_filter).body();
Parameter parameter = ((Scope)_filter).parameter(0);
_extractFilters(filter,filters);
for (int i=0; i