@Override public boolean retainAll(Collection<?> c) { return pipeList.retainAll(c); }
/** * @see java.util.Collection#retainAll(java.util.Collection) */ public boolean retainAll(Collection<?> c) { return this.elements.retainAll(c); }
@Override public boolean retainAll(Collection<?> c) { return pipeList.retainAll(c); }
/** * @see List#retainAll(Collection) */ @Override public boolean retainAll(Collection<?> c) { return this.processors.retainAll(c); }
/** * @see List#retainAll(Collection) */ @Override public boolean retainAll(Collection<?> c) { return this.processors.retainAll(c); }
@Override public boolean retainAll(Collection<?> c) { return this.ruleList.retainAll(c); }
@Override public boolean retainAll(Collection<?> c) { return list.retainAll(c); }
@Override public boolean retainAll(Collection<?> c) { return list.retainAll(c); }
public synchronized boolean retainAll(Collection<?> c) { return list.retainAll(c); }
public boolean retainAll(Collection<?> c) { return sortedList.retainAll(c); }
@Override public boolean retainAll(Collection<?> c) { try { lock.writeLock().lock(); it = null; return super.retainAll(c); } finally { lock.writeLock().unlock(); } }
@Override public boolean retainAll(Collection<?> c) { boolean r = super.retainAll(c); riseListChanged(); return r; }
@Override public boolean retainAll(Collection<?> c) { boolean r = super.retainAll(c); riseListChanged(); return r; }
@Override public boolean retainAll(Collection<?> c) { boolean r = super.retainAll(c); riseListChanged(); return r; }
/** * Calculate projection orderings that allow indexed joins to function * optimally. * * @param self the tuples for which to generate a projection ordering * @param other the tuples the generated projection ordering should match * @return the projection ordering */ private static List generateProjectionOrder(Tuples self, Tuples other) { // Calculate a new column ordering for self which moves all the columns // it has in common with the other into its prefix LinkedList selfColumns = new LinkedList(Arrays.asList(self.getVariables())); List otherColumns = Arrays.asList(other.getVariables()); LinkedList suffix = new LinkedList(Arrays.asList(self.getVariables())); suffix.removeAll(otherColumns); selfColumns.retainAll(otherColumns); selfColumns.addAll(suffix); return selfColumns; }
/** * This method returns the nodes of a digraph in such an order that as one * iterates through the list, the parents of each node have already been * encountered in the list. * * @return a tier ordering for the nodes in this graph. */ private LinkedList<SessionNode> getTierOrdering(SessionNode node) { Session session = this.session; Set<SessionNode> sessionNodes = session.getNodes(); LinkedList<SessionNode> found = new LinkedList<>(); Set<SessionNode> notFound = new HashSet<>(); // The getVariableNodes() method already returns a copy, so there's no // need to make a new copy. notFound.addAll(sessionNodes); while (!notFound.isEmpty()) { for (Iterator<SessionNode> it = notFound.iterator(); it.hasNext(); ) { SessionNode sessionNode = it.next(); if (found.containsAll(sessionNode.getParents())) { found.add(sessionNode); it.remove(); } } } found.retainAll(getDescendants(node)); return found; }
@Override public boolean retainAll(Collection paramCollection) { if (_directAccess) { return super.retainAll(paramCollection); } if (isDelayLoad()) { load(); } return ProxyCollections.retainAll(this, paramCollection); }
@Override public boolean retainAll(Collection paramCollection) { if (_directAccess) { return super.retainAll(paramCollection); } if (isDelayLoad()) { load(); } return ProxyCollections.retainAll(this, paramCollection); }
@Override public boolean retainAll(Collection paramCollection) { if (_directAccess) { return super.retainAll(paramCollection); } if (isDelayLoad()) { load(); } return ProxyCollections.retainAll(this, paramCollection); }
@Override public boolean retainAll(Collection paramCollection) { if (_directAccess) { return super.retainAll(paramCollection); } if (isDelayLoad()) { load(); } return ProxyCollections.retainAll(this, paramCollection); }