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

Introduction

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

Prototype

public static <I, O> Iterator<O> transformedIterator(final Iterator<? extends I> iterator,
        final Transformer<? super I, ? extends O> transform) 

Source Link

Document

Gets an iterator that transforms the elements of another iterator.

Usage

From source file:com.tussle.script.StackedBindings.java

public Set<Map.Entry<String, Object>> entrySet() {
    if (entrySet == null)
        entrySet = new AbstractSet<Map.Entry<String, Object>>() {
            public Iterator<Map.Entry<String, Object>> iterator() {
                return IteratorUtils.transformedIterator(bindingMap.entrySet().iterator(),
                        StackedBindingsEntry::new);
            }//from   w ww .  ja  va 2s. c om

            public int size() {
                return bindingMap.size();
            }
        };
    return entrySet;
}

---

From source file:com.tussle.script.StackedBindings.java

public Set<String> keySet() {
    if (keySet == null)
        keySet = new AbstractSet<String>() {
            public Iterator<String> iterator() {
                return IteratorUtils.transformedIterator(bindingMap.entrySet().iterator(), Entry::getKey);
            }//from  w  w  w. j a  v a 2 s .  co m

            public int size() {
                return bindingMap.size();
            }
        };
    return keySet;
}

---

From source file:com.tussle.script.StackedBindings.java

public Collection<Object> values() {
    if (values == null)
        values = new AbstractCollection<Object>() {
            public Iterator<Object> iterator() {
                return IteratorUtils.transformedIterator(bindingMap.values().iterator(), Deque::peek);
            }/*from   w ww .  j  av  a2  s  .c  o m*/

            public int size() {
                return bindingMap.size();
            }
        };
    return values;
}

---

From source file:com.premiumminds.webapp.wicket.repeaters.AjaxListSetView.java

@Override
protected Iterator<? extends Component> renderIterator() {
    return IteratorUtils.transformedIterator(getList().iterator(), new Transformer<T, ListSetItem<?>>() {

        @Override//w w  w. ja  v a  2 s . co m
        public ListSetItem<?> transform(T el) {
            ListSetItem<?> component = elementToComponent.get(el);
            if (component == null)
                throw new IllegalStateException("could not find element '" + el + "' on computed map");
            return component;
        }
    });
}

---

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

/**
 *
 * @param startAt/*from   w w w.j a  v  a2s.  c  om*/
 * @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:uniol.apt.analysis.synthesize.FindWords.java

static private void generateList(final PNProperties properties, SortedSet<Character> alphabet,
        final boolean quickFail, WordCallback wordCallback, LengthDoneCallback lengthDoneCallback,
        ForkJoinPool executor) throws PreconditionFailedException {
    if (properties.isPlain() && properties.isKMarking())
        throw new PreconditionFailedException("The combination of plain and k-marking is not supported"
                + ", because 'minimal unsolvable' cannot be defined");

    CompletionService<Pair<String, SynthesizePN>> completion = new ExecutorCompletionService<>(executor);
    List<String> currentLevel = Collections.singletonList("");
    while (!currentLevel.isEmpty()) {

        // Lazily create new Callables to avoid OOM errors
        Iterator<Callable<Pair<String, SynthesizePN>>> jobGenerator = IteratorUtils.transformedIterator(
                new NextWordsIterator(properties, alphabet, currentLevel),
                new Transformer<String, Callable<Pair<String, SynthesizePN>>>() {
                    @Override/*from  ww w  .j  a  v  a2  s.c om*/
                    public Callable<Pair<String, SynthesizePN>> transform(final String word) {
                        return new Callable<Pair<String, SynthesizePN>>() {
                            @Override
                            public Pair<String, SynthesizePN> call() {
                                List<Character> wordList = toList(word);
                                SynthesizePN synthesize = solveWord(wordList, properties, quickFail);
                                return new Pair<>(word, synthesize);
                            }
                        };
                    }
                });

        // Wait for and handle results
        List<String> nextLevel = new ArrayList<>();
        int tasksSubmitted = submitTasks(executor, completion, jobGenerator);
        int tasksFinished = 0;
        while (tasksSubmitted != tasksFinished) {
            String word;
            SynthesizePN synthesize;
            try {
                Pair<String, SynthesizePN> pair = completion.take().get();
                word = pair.getFirst();
                synthesize = pair.getSecond();
            } catch (ExecutionException e) {
                throw new RuntimeException(e);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }

            List<Character> wordList = toList(word);
            wordCallback.call(wordList, word, synthesize);
            if (synthesize.wasSuccessfullySeparated()) {
                nextLevel.add(word);
            }
            tasksFinished++;

            tasksSubmitted += submitTasks(executor, completion, jobGenerator);
        }

        int currentLength = currentLevel.iterator().next().length() + 1;
        lengthDoneCallback.call(currentLength);
        currentLevel = nextLevel;
        Collections.sort(currentLevel);
    }
}

---