Java OrPredicate类代码示例

import prefuse.data.expression.OrPredicate; //导入依赖的package包/类
protected static IntIterator getOrIterator(Table t, OrPredicate op) {
    int size = op.size();
    if ( size > 1 ) {
        // if all subclauses can be optimized, we can optimize the query
        IntIterator[] rows = new IntIterator[size];
        for ( int i=0; i<rows.length; ++i ) {
            rows[i] = getOptimizedIterator(t, op.get(i));
            
            // all clauses must be optimized to avoid linear scan
            if ( rows[i] == null ) return null;
        }
        // group iterators, and filter for uniqueness
        return new UniqueRowIterator(new CompositeIntIterator(rows));
    } else if ( size == 1 ) {
        // only one clause, optimize for that
        return getOptimizedIterator(t, op.get(0));
    } else {
        // no woman, no cry
        return null;
    }
}
 

import prefuse.data.expression.OrPredicate; //导入依赖的package包/类
public void valueChanged(ListSelectionEvent e) {
    ListModel model = (ListModel)e.getSource();
    OrPredicate orP = (OrPredicate)m_query;
    
    if ( model.isSelectionEmpty() )
    {
        orP.clear();
    }
    else if ( m_includeAll && model.isSelectedIndex(0) )
    {
        orP.set(BooleanLiteral.TRUE);
    }
    else
    {
        int min   = model.getMinSelectionIndex();
        int max   = model.getMaxSelectionIndex();
        int count = 0;
        for ( int i=min; i<=max; ++i ) {
            if ( model.isSelectedIndex(i) )
                ++count;
        }
    
        if ( count == model.getSize() ) {
            orP.set(BooleanLiteral.TRUE);
        } else if ( count == 1 ) {
            orP.set(getComparison(model.getElementAt(min)));
        } else {
            Predicate[] p = new Predicate[count];
            for ( int i=min, j=0; i<=max; ++i ) {
                if ( model.isSelectedIndex(i) )
                    p[j++] = getComparison(model.getElementAt(i));
            }
            orP.set(p);
        }
    }
}
 

import prefuse.data.expression.OrPredicate; //导入依赖的package包/类
private void initPredicate() {
    // set up predicate
    OrPredicate orP = new OrPredicate();
    orP.add(BooleanLiteral.TRUE);
    setPredicate(orP);
}
 

import prefuse.data.expression.OrPredicate; //导入依赖的package包/类
/**
 * Get an optimized iterator over the rows of a table, if possible.
 * @param t the Table to iterator over
 * @param p the filter predicate
 * @return an optimized iterator, or null if no optimization was found
 */
protected static IntIterator getOptimizedIterator(Table t, Predicate p) {
    if ( t.getRowCount() < OPTIMIZATION_THRESHOLD ) 
        return null; // avoid overhead for small tables
    
    if ( p instanceof ColumnExpression ) {
        // try to optimize a boolean column
        return getColumnIterator(t,
                ((ColumnExpression)p).getColumnName(), true);
    }
    else if ( p instanceof NotPredicate )
    {
        // try to optimize the negation a boolean column
        Predicate pp = ((NotPredicate)p).getPredicate();
        if ( pp instanceof ColumnExpression ) {
            return getColumnIterator(t,
                    ((ColumnExpression)pp).getColumnName(), false);
        }
    }
    else if ( p instanceof AndPredicate )
    {
        // try to optimize an and clause
        return getAndIterator(t, (AndPredicate)p);
    }
    else if ( p instanceof OrPredicate )
    {
        // try to optimize an or clause
        return getOrIterator(t, (OrPredicate)p);
    }
    else if ( p instanceof ComparisonPredicate )
    {
        // try to optimize a comparison (=, !=, <, > ,etc)
        return getComparisonIterator(t,(ComparisonPredicate)p);
    }
    else if ( p instanceof RangePredicate )
    {
        // try to optimize a bounded range of values
        return getRangeIterator(t, (RangePredicate)p); 
    }
    
    return null;
}
 

import prefuse.data.expression.OrPredicate; //导入依赖的package包/类
/**
 * Set the test predicate used to determine visibility.
 * @param p the test predicate to set
 */
protected void setPredicate(Predicate p) {
    m_predicate = p;
    m_filter = new OrPredicate(p, VisiblePredicate.TRUE);
}