Example usage for org.apache.commons.collections4 IteratorUtils filteredIterator

Introduction

In this page you can find the example usage for org.apache.commons.collections4 IteratorUtils filteredIterator.

Prototype

public static <E> Iterator<E> filteredIterator(final Iterator<? extends E> iterator,
        final Predicate<? super E> predicate) 

Source Link

Document

Gets an iterator that filters another iterator.

Usage

From source file:com.link_intersystems.util.graph.GraphFacade.java

/**
 * Creates a predicated {@link Node} iterator that iterates the {@link Node}
 * s per Predicate that is specified using the {@link NodeIterateStrategy}.
 * <p>/*from ww  w . j a v a 2  s .  com*/
 * Take the following node structure for example
 *
 * <pre>
 *                   A
 *      +------------+------------+
 *      B            C            D
 * +----+----+       |        +---+------------+
 * E    F    G       H        I   J            K
 *                                      +------+------+
 *                                      L      M      N
 * </pre>
 *
 * If we assume that we have 3 {@link Predicate}s
 * <ul>
 * <li>The 1. {@link Predicate} matches {@link Node}s A,C,H,D,K</li>
 * <li>The 2. {@link Predicate} matches {@link Node}s A,B,E,F</li>
 * <li>The 3. {@link Predicate} matches {@link Node}s D,J,M,N</li>
 * </ul>
 * and we construct a per predicated node iterator using
 *
 * <pre>
 * {@link GraphFacade#perPredicateNodeIterator(NodeIterateStrategy, Node, Predicate...) GraphFacade.perPredicatedNodeIterator(BREADTH_FIRST, startNodeA, pred1, pred2, pred3)};
 * </pre>
 *
 * The resulting iterator will iterate the node structure using a breadth
 * first strategy for every {@link Predicate} starting at startNodeA. <br/>
 * The result will be:
 *
 * <pre>
 * breadth first  breadth first   breadth first
 *   matching       matching       matching
 *    pred1          pred2           pred3
 * +-----------+   +-------+       +-------+
 *   A C D H K      A B E F         D J M N
 *
 * iterate order -->
 * </pre>
 *
 * </p>
 *
 * @param nodeIterateStrategy
 * @param startNode
 * @param nodeIterateOrderPredicates
 * @return
 */
@SuppressWarnings("unchecked")
public static Iterator<Node> perPredicateNodeIterator(NodeIterateStrategy nodeIterateStrategy, Node startNode,
        Predicate... nodeIterateOrderPredicates) {
    Iterator<Node> iterator = IteratorUtils.EMPTY_ITERATOR;
    for (int i = 0; i < nodeIterateOrderPredicates.length; i++) {
        Predicate predicate = nodeIterateOrderPredicates[i];
        Iterator<Node> nodeStrategyIterator = null;
        switch (nodeIterateStrategy) {
        case BREADTH_FIRST:
            nodeStrategyIterator = new BreadthFirstNodeIterator(startNode);
            break;
        case DEPTH_FIRST:
            nodeStrategyIterator = new DepthFirstNodeIterator(startNode);
            break;
        }
        Iterator<Node> predicateFilterIterator = IteratorUtils.filteredIterator(nodeStrategyIterator,
                predicate);
        iterator = IteratorUtils.chainedIterator(iterator, predicateFilterIterator);
    }
    return iterator;
}

---

From source file:com.link_intersystems.lang.reflect.criteria.ElementCriteria.java

/**
 * Takes the iterator and wraps it into a filtering iterator that applies
 * the {@link Predicate}s that were configured via {@link #add(Predicate)}.
 *
 * @param <T>//from w  w w .  j ava 2  s .  c  o  m
 * @param iterator
 * @return an {@link Iterator} that filters the elements of the given
 *         {@link Iterator} according to the filter {@link Predicate}s
 *         defined by {@link #add(Predicate)}.
 * @since 1.0.0.0
 */
protected Iterator<T> applyElementFilter(Iterator<T> iterator) {
    if (elementFilterPredicate == null) {
        return iterator;
    } else {
        return IteratorUtils.filteredIterator(iterator, elementFilterPredicate);
    }
}

---

From source file:com.link_intersystems.lang.reflect.criteria.ElementCriteria.java

/**
 * Takes the iterator and wraps it into a filtering iterator that applies
 * the selection requirements as they are configured via
 * {@link #setResult(Result)}.// w  ww . java  2 s  .com
 *
 * @param <T>
 * @param iterator
 * @return an {@link Iterator} that selects the elements of the given
 *         {@link Iterator} according to selection as specified by
 *         {@link #setResult(Result)}.
 *
 * @since 1.0.0.0
 */
protected Iterator<T> applySelectionFilter(final Iterator<T> iterator) {
    Iterator<T> result = null;
    switch (select) {
    case FIRST:
        Predicate<Object> firstPredicate = new Predicate<Object>() {

            private boolean first = true;

            public boolean evaluate(Object object) {
                if (first) {
                    first = false;
                    return true;
                }
                return false;
            }
        };
        result = IteratorUtils.filteredIterator(iterator, firstPredicate);
        break;
    case LAST:
        Predicate<Object> lastElementPredicate = new Predicate<Object>() {

            public boolean evaluate(Object object) {
                return !iterator.hasNext();
            }
        };
        result = IteratorUtils.filteredIterator(iterator, lastElementPredicate);
        break;
    case ALL:
        result = iterator;
        break;
    }
    return result;
}

---

From source file:com.link_intersystems.beans.BeanClass.java

/**
 * Returns true if the method is a method to access a property (either get,
 * is, set). The equality is based on the method's signature. This means
 * that even property accessor methods in super classes will be recognized
 * as property accessor methods of this {@link BeanClass}.
 *
 * @param method/*from   www  .  j a  va2  s .  c  om*/
 *            the method to test if it is a property accessor method of this
 *            class.
 * @return true if the given method is a property accessor method of this
 *         class.
 * @since 1.2.0.0
 */
@SuppressWarnings("unchecked")
public boolean isPropertyAccessor(Method method) {
    Class<?> declaringClass = method.getDeclaringClass();
    Class<T> beanType = getType();
    boolean isInHierarchy = declaringClass.isAssignableFrom(beanType);
    if (!isInHierarchy) {
        return false;
    }
    Map<String, PropertyDescriptor> propertyDescriptors = getPropertyDescriptors();
    Collection<PropertyDescriptor> propertyDescriptorCollection = propertyDescriptors.values();
    Predicate predicate = new SignaturePredicate(method);
    Iterator<Method> propertyMethodsIterator = IteratorUtils.objectGraphIterator(
            propertyDescriptorCollection.iterator(), PropertyDescriptor2AccessorsTransformer.INSTANCE);
    Iterator<Method> filteredIterator = IteratorUtils.filteredIterator(propertyMethodsIterator, predicate);
    return filteredIterator.hasNext();
}

---

From source file:com.link_intersystems.lang.reflect.criteria.ClassCriteria.java

/**
 *
 * @param startAt/*  www  .  ja va 2s .  c  o  m*/
 * @param stopAt
 * @return an {@link Iterable} that iterates through the class hierarchy as
 *         defined by this criteria starting at the given class and stopping
 *         at the given class.
 * @throws NullArgumentException
 *             if the stop class is not a superclass of the start class.
 * @since 1.0.0.0
 */
public Iterable<Class<?>> getIterable(Class<?> startAt, Class<?> stopAt) {
    Assert.notNull("startAt", startAt);
    if (stopAt != null && !stopAt.isAssignableFrom(startAt)) {
        throw new IllegalArgumentException("stopAt " + stopAt + " must be a superclass of " + startAt);
    }
    class StartAtIterable implements Iterable<Class<?>> {

        private final Class<?> startAt;
        private final ObjectFactory<ClassCriteria> templateObjectFactory;

        public StartAtIterable(Class<?> startAt, ObjectFactory<ClassCriteria> classCriteria) {
            this.templateObjectFactory = classCriteria;
            this.startAt = startAt;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        public Iterator<Class<?>> iterator() {
            ClassCriteria classCriteriaCopy = templateObjectFactory.getObject();
            TraverseStrategy traverseStrategy = classCriteriaCopy.traverseStrategy;
            boolean separatedClassTypeTraversal = classCriteriaCopy.separatedClassTypeTraversal;
            Comparator<Class<?>> interfacesComparator = classCriteriaCopy.interfacesComparator;
            Comparator<Class<?>> innerClassesComparator = classCriteriaCopy.innerClassesComparator;
            ClassType[] classTypes = classCriteriaCopy.classTypes;
            ClassNode rootNode = new ClassNode(startAt, classTypes);

            rootNode.setInterfacesOrder(interfacesComparator);
            rootNode.setInnerClassesOrder(innerClassesComparator);

            class Node2ClassTransformer implements Transformer {

                public Object transform(Object input) {
                    Node node = Node.class.cast(input);
                    Object userObject = node.getUserObject();
                    Class<?> clazz = Class.class.cast(userObject);
                    return clazz;
                }

            }
            Iterator<Node> classNodeIterator = null;
            Iterator classesIterator = null;
            if (separatedClassTypeTraversal) {
                NodeIterateStrategy nodeIterateStrategy = NodeIterateStrategy.valueOf(traverseStrategy.name());
                Predicate[] nodeIteratePredicates = new Predicate[classTypes.length];
                Node2ClassTransformer node2ClassTransformer = new Node2ClassTransformer();
                for (int i = 0; i < classTypes.length; i++) {
                    ClassType classType = classTypes[i];
                    ClassTypePredicate classTypePredicate = new ClassTypePredicate(classType);
                    TransformedPredicate transformedPredicate = new TransformedPredicate(node2ClassTransformer,
                            classTypePredicate);
                    nodeIteratePredicates[i] = transformedPredicate;
                }
                classNodeIterator = GraphFacade.perPredicateNodeIterator(nodeIterateStrategy, rootNode,
                        nodeIteratePredicates);
                classesIterator = IteratorUtils.transformedIterator(classNodeIterator,
                        new Node2ClassTransformer());
            } else {
                switch (classCriteriaCopy.traverseStrategy) {
                case BREADTH_FIRST:
                    classNodeIterator = new BreadthFirstNodeIterator(rootNode);
                    break;
                case DEPTH_FIRST:
                    classNodeIterator = new DepthFirstNodeIterator(rootNode);
                    break;
                }
                classesIterator = IteratorUtils.transformedIterator(classNodeIterator,
                        new Node2ClassTransformer());
            }

            ClassTypePredicate classTypePredicate = new ClassTypePredicate(classTypes);
            classesIterator = IteratorUtils.filteredIterator(classesIterator, classTypePredicate);

            classesIterator = classCriteriaCopy.applyTraverseClassesUniquely(classesIterator);

            classesIterator = classCriteriaCopy.applyStopAtFilter(classesIterator);

            classesIterator = classCriteriaCopy.applyElementFilter(classesIterator);

            classesIterator = classCriteriaCopy.applySelectionFilter(classesIterator);

            return classesIterator;
        }

    }

    return new StartAtIterable(startAt, getObjectFactory());
}

---

From source file:com.link_intersystems.lang.reflect.criteria.ClassCriteria.java

@SuppressWarnings("unchecked")
protected Iterator<Class<?>> applyTraverseClassesUniquely(Iterator<Class<?>> iterator) {
    if (isTraverseClassesUniquelyEnabled()) {
        iterator = IteratorUtils.filteredIterator(iterator, UniquePredicate.uniquePredicate());
    }/*from  w w w.  jav a 2  s. co m*/
    return iterator;
}

---

From source file:com.link_intersystems.lang.reflect.criteria.ClassCriteria.java

@SuppressWarnings("unchecked")
protected Iterator<Class<?>> applyStopAtFilter(Iterator<Class<?>> iterator) {
    if (stopClass != null) {
        Predicate stopPredicate = ReflectFacade.getIsAssignablePredicate(stopClass);
        iterator = IteratorUtils.filteredIterator(iterator, stopPredicate);
    }/*from w w w. j  ava 2  s.  c om*/
    return iterator;
}

---

From source file:com.link_intersystems.lang.reflect.criteria.MemberCriteria.java

@SuppressWarnings("unchecked")
protected Iterator<T> applyAccessAndNamePredicates(Iterator<T> iterator) {
    List<Predicate<?>> predicates = new ArrayList<Predicate<?>>();

    int accessModifiers = 0;
    Collection<AccessType> accesses = getAccesses();
    for (AccessType access : accesses) {
        switch (access) {
        case PUBLIC:
            accessModifiers |= Modifier.PUBLIC;
            break;
        case PRIVATE:
            accessModifiers |= Modifier.PRIVATE;
            break;
        case PROTECTED:
            accessModifiers |= Modifier.PROTECTED;
            break;
        default:// w ww .ja  va2 s  . c o  m
            break;
        }
    }
    Predicate<Member> accessModifierPredicate = new MemberModifierPredicate(accessModifiers,
            Match.AT_LEAST_ONE);

    if (accesses.contains(AccessType.DEFAULT)) {
        accessModifierPredicate = OrPredicate.orPredicate(accessModifierPredicate,
                NotPredicate.notPredicate(new MemberModifierPredicate(
                        Modifier.PRIVATE | Modifier.PUBLIC | Modifier.PROTECTED, Match.AT_LEAST_ONE)));
    }

    predicates.add(accessModifierPredicate);

    int modifiers = getModifiers();
    if (modifiers != 0) {
        predicates.add(new MemberModifierPredicate(modifiers, Match.AT_LEAST_ALL));
    }

    String name = getName();
    if (name != null) {
        predicates.add(ReflectFacade.getMemberNamePredicate(name));
    }

    Pattern pattern = getPattern();
    if (pattern != null) {
        predicates.add(ReflectFacade.getMemberNamePatternPredicate(pattern));
    }
    Predicate<T> allPredicate = AllPredicate.allPredicate((Collection<? extends Predicate<T>>) predicates);
    iterator = IteratorUtils.filteredIterator(iterator, allPredicate);
    return iterator;
}

---

From source file:org.apache.syncope.core.logic.LoggerLogic.java

@PreAuthorize("hasRole('" + StandardEntitlement.AUDIT_LIST + "')")
@Transactional(readOnly = true)/*from   w w  w.jav a  2 s  . c om*/
public List<AuditLoggerName> listAudits() {
    return CollectionUtils.collect(IteratorUtils.filteredIterator(list(LoggerType.AUDIT).iterator(),
            PredicateUtils.notNullPredicate()), new Transformer<LoggerTO, AuditLoggerName>() {

                @Override
                public AuditLoggerName transform(final LoggerTO logger) {
                    AuditLoggerName result = null;
                    try {
                        result = AuditLoggerName.fromLoggerName(logger.getKey());
                    } catch (Exception e) {
                        LOG.warn("Unexpected audit logger name: {}", logger.getKey(), e);
                    }

                    return result;
                }
            }, new ArrayList<AuditLoggerName>());
}

---

From source file:org.apache.syncope.core.misc.security.SyncopeUserDetailsService.java

@Override
public UserDetails loadUserByUsername(final String username) {
    final Set<SyncopeGrantedAuthority> authorities = new HashSet<>();
    if (anonymousUser.equals(username)) {
        authorities.add(new SyncopeGrantedAuthority(Entitlement.ANONYMOUS));
    } else if (adminUser.equals(username)) {
        CollectionUtils/* ww w.  jav a  2  s.  c  o m*/
                .collect(
                        IteratorUtils.filteredIterator(Entitlement.values().iterator(),
                                PredicateUtils
                                        .notPredicate(PredicateUtils.equalPredicate(Entitlement.ANONYMOUS))),
                        new Transformer<String, SyncopeGrantedAuthority>() {

                            @Override
                            public SyncopeGrantedAuthority transform(final String entitlement) {
                                return new SyncopeGrantedAuthority(entitlement, SyncopeConstants.ROOT_REALM);
                            }
                        }, authorities);
    } else {
        org.apache.syncope.core.persistence.api.entity.user.User user = userDAO.find(username);
        if (user == null) {
            throw new UsernameNotFoundException("Could not find any user with id " + username);
        }

        // Give entitlements as assigned by roles (with realms, where applicable) - assigned either
        // statically and dynamically
        for (final Role role : userDAO.findAllRoles(user)) {
            CollectionUtils.forAllDo(role.getEntitlements(), new Closure<String>() {

                @Override
                public void execute(final String entitlement) {
                    SyncopeGrantedAuthority authority = new SyncopeGrantedAuthority(entitlement);
                    authorities.add(authority);

                    List<String> realmFullPahs = new ArrayList<>();
                    CollectionUtils.collect(role.getRealms(), new Transformer<Realm, String>() {

                        @Override
                        public String transform(final Realm realm) {
                            return realm.getFullPath();
                        }
                    }, realmFullPahs);
                    authority.addRealms(realmFullPahs);
                }
            });
        }

        // Give group entitlements for owned groups
        for (Group group : groupDAO.findOwnedByUser(user.getKey())) {
            for (String entitlement : Arrays.asList(Entitlement.GROUP_READ, Entitlement.GROUP_UPDATE,
                    Entitlement.GROUP_DELETE)) {

                SyncopeGrantedAuthority authority = new SyncopeGrantedAuthority(entitlement);
                authority.addRealm(
                        RealmUtils.getGroupOwnerRealm(group.getRealm().getFullPath(), group.getKey()));
                authorities.add(authority);
            }
        }
    }

    return new User(username, "<PASSWORD_PLACEHOLDER>", authorities);
}

---