protected void filterMapFormProperties(List<Property> mapFormProperties, final List<String> classNames) { CollectionUtils.filter(mapFormProperties, new Predicate() { @Override public boolean evaluate(Object object) { Property p = (Property) object; for (String availType : p.getMetadata().getAvailableToTypes()) { if (classNames.contains(availType)) { return true; } } return false; } }); }
protected void addChildOrderItemsToCandidates(Offer offer, CandidatePromotionItems candidates, OfferItemCriteria criteria, List<PromotableOrderItem> promotableOrderItems, PromotableOrderItem item) { if (offer.getApplyToChildItems()) { final List<OrderItem> childItems = item.getOrderItem().getChildOrderItems(); if (CollectionUtils.isEmpty(childItems)) { return; } List<PromotableOrderItem> filteredItems = new ArrayList<>(); filteredItems.addAll(promotableOrderItems); CollectionUtils.filter(filteredItems, new TypedPredicate<PromotableOrderItem>() { @Override public boolean eval(PromotableOrderItem promotableOrderItem) { return childItems.contains(promotableOrderItem.getOrderItem()); } }); for (PromotableOrderItem promotableOrderItem : filteredItems) { candidates.addTarget(criteria, promotableOrderItem); } } }
if (parentCategory != null && !categoryHierarchy.contains(parentCategory)) { parentFacets = parentCategory.getCumulativeSearchFacets(categoryHierarchy); CollectionUtils.filter(parentFacets, new Predicate() { @Override public boolean evaluate(Object arg) {
public void testFilter() { List list = new ArrayList(); list.add("One"); list.add("Two"); list.add("Three"); list.add("Four"); CollectionUtils.filter(list, EQUALS_TWO); assertEquals(1, list.size()); assertEquals("Two", list.get(0)); list = new ArrayList(); list.add("One"); list.add("Two"); list.add("Three"); list.add("Four"); CollectionUtils.filter(list, null); assertEquals(4, list.size()); CollectionUtils.filter(null, EQUALS_TWO); assertEquals(4, list.size()); CollectionUtils.filter(null, null); assertEquals(4, list.size()); }
protected List<CategorySearchFacet> getParentFacets(final Collection<SearchFacet> facets) { List<CategorySearchFacet> parentFacets = null; if (getParentCategory() != null) { parentFacets = getParentCategory().getCumulativeSearchFacets(); CollectionUtils.filter(parentFacets, new Predicate() { @Override public boolean evaluate(Object arg) { CategorySearchFacet csf = (CategorySearchFacet) arg; return !isExcludedSearchFacet(csf) && !facets.contains(csf.getSearchFacet()); } protected boolean isExcludedSearchFacet(CategorySearchFacet csf) { boolean isExcludedSearchFacet = false; for (CategoryExcludedSearchFacet excludedSearchFacet : getExcludedSearchFacets()) { if (excludedSearchFacet.getSearchFacet().equals(csf.getSearchFacet())) { isExcludedSearchFacet = true; break; } } return isExcludedSearchFacet; } }); } return parentFacets; }
@Override @Transactional("blTransactionManager") public Order addAllItemsFromNamedOrder(Order namedOrder, boolean priceOrder) throws RemoveFromCartException, AddToCartException { Order cartOrder = orderDao.readCartForCustomer(namedOrder.getCustomer()); if (cartOrder == null) { cartOrder = createNewCartForCustomer(namedOrder.getCustomer()); } List<OrderItem> items = new ArrayList<OrderItem>(namedOrder.getOrderItems()); // Remove any order items that are children CollectionUtils.filter(items, new TypedPredicate<OrderItem>() { @Override public boolean eval(OrderItem orderItem) { return orderItem.getParentOrderItem() == null; } }); for (OrderItem item : items) { OrderItemRequestDTO orderItemRequest = orderItemService.buildOrderItemRequestDTOFromOrderItem(item); cartOrder = addItem(cartOrder.getId(), orderItemRequest, priceOrder); if (moveNamedOrderItems) { removeItem(namedOrder.getId(), item.getId(), false); } } if (deleteEmptyNamedOrders) { cancelOrder(namedOrder); } return cartOrder; }
/** * Attempts to find all children requested by the ChildByNameConstraint * in cache. Returns null if the complete list is not found. */ private List<RolapMember> findNamedChildrenInCache( final RolapMember parent, final List<String> childNames) { List<RolapMember> children = checkDefaultAndNamedChildrenCache(parent); if (children == null || childNames == null || childNames.size() > children.size()) { return null; } filter( children, new Predicate() { public boolean evaluate(Object member) { return childNames.contains( ((RolapMember) member).getName()); } }); boolean foundAll = children.size() == childNames.size(); return !foundAll ? null : children; }
/** * Filters the children list to those that contain identifiers * we think we can batch resolve, then transforms the Id list * to the corresponding NameSegment. */ private List<Id.NameSegment> collectChildrenNameSegments( final Member parentMember, List<Id> children) { filter( children, new Predicate() { // remove children we can't support public boolean evaluate(Object theId) { Id id = (Id)theId; return !Util.matches(parentMember, id.getSegments()) && supportedIdentifier(id); } }); return new ArrayList( CollectionUtils.collect( children, new Transformer() { // convert the collection to a list of NameSegments public Object transform(Object theId) { Id id = (Id)theId; return getLastSegment(id); } })); }
/** * Checks access rights and hidden status on the members * in each tuple in tupleList. */ private TupleList filterInaccessibleTuples(TupleList tupleList) { if (needsFiltering(tupleList)) { final Predicate memberInaccessible = memberInaccessiblePredicate(); filter( tupleList, tupleAccessiblePredicate(memberInaccessible)); } return tupleList; }
CollectionUtils.filter(visits, new AttributeMatcherPredicate<Visit, VisitAttributeType>( serializedAttributeValues));
/** * @see org.openmrs.api.db.ProviderDAO#getProviders(String, Map, Integer, Integer, boolean) */ @Override public List<Provider> getProviders(String name, Map<ProviderAttributeType, String> serializedAttributeValues, Integer start, Integer length, boolean includeRetired) { Criteria criteria = prepareProviderCriteria(name, includeRetired); if (start != null) { criteria.setFirstResult(start); } if (length != null) { criteria.setMaxResults(length); } if (includeRetired) { //push retired Provider to the end of the returned list criteria.addOrder(Order.asc("retired")); } List<Provider> providers = criteria.list(); if (serializedAttributeValues != null) { CollectionUtils.filter(providers, new AttributeMatcherPredicate<Provider, ProviderAttributeType>( serializedAttributeValues)); } return providers; }
private List<IsisViewer> findWebViewers(final List<IsisViewer> viewers) { final List<IsisViewer> webViewers = new ArrayList<IsisViewer>(viewers); CollectionUtils.filter(webViewers, new Predicate() { @Override public boolean evaluate(final Object object) { final IsisViewer viewer = (IsisViewer) object; return viewer.getWebAppSpecification() != null; } }); return webViewers; }
private List<NakedObjectsViewer> findWebViewers(List<NakedObjectsViewer> viewers) { List<NakedObjectsViewer> webViewers = new ArrayList<NakedObjectsViewer>(viewers); CollectionUtils.filter(webViewers, new Predicate() { public boolean evaluate(Object object) { NakedObjectsViewer viewer = (NakedObjectsViewer) object; return viewer.getWebAppSpecification() != null; } }); return webViewers; }
/** * Constructor for the FilterCollection object * * @param collection */ public FilteredCollection(Collection collection) { this.addAll(collection); CollectionUtils.filter( this, this); }
public List<Entry> getExecutions() { if (StringUtils.isNotBlank(filter)) { CollectionUtils.filter(executions, new ExecutionHistoryFilter(filter)); } return executions; }
@Override public List<Script> findAll(Predicate filter, ResourceResolver resolver) { final List<Script> scripts = findAll(resolver); CollectionUtils.filter(scripts, filter); return scripts; }
@Override public PowerList<E> remove(Criteria<E> criteria) { CollectionUtils.filter(this, predicate(criteria.not())); return this; }
@Override public Collection<SearchRequest> getNonPrivateFilters(final ApplicationUser user) { final Collection<SearchRequest> filters = getOwnedFilters(user); CollectionUtils.filter(filters, o -> !((SearchRequest) o).getPermissions().isPrivate()); return filters; }
private void addValidationErrorsToForm(final FormComponent form, final List<Entity> messagesList) { final Entity entity = form.getEntity(); final List<Entity> messages = Lists.newArrayList(messagesList); CollectionUtils.filter(messages, VALIDATION_MESSAGES_PREDICATE); for (Entity message : messages) { assignMessageToEntity(entity, message); } if (!entity.isValid()) { form.addMessage("qcadooView.message.saveFailedMessage", MessageType.FAILURE); } form.setEntity(entity); }
@Override protected Object authorize(Object object) { Predicate predicate = new SettingsFilter(PUBLIC_SETTINGS.get(), ApiContext.getContext().getApiRequest()); if (object instanceof List<?>) { List<Object> list = new ArrayList<>((List<?>) object); org.apache.commons.collections.CollectionUtils.filter(list, predicate); return super.authorize(list); } else if (predicate.evaluate(object)){ return super.authorize(object); } return null; }