Package org.xmlunit.util

Class Linqy

  • public final class Linqy
extends Object
    A couple of (functional) sequence processing constructs.

    • Method Detail

      • asList

        public static <E> List<E> asList​(Iterable<E> i)
        Turns the iterable into a list.
        Type Parameters:
        E - element type
        Parameters:
        i - the iterable
        Returns:
        a list containing all elements of the Iterable passed in

      • cast

        public static <E> Iterable<E> cast​(Iterable i)
        Turns an iterable into its type-safe cousin.
        Type Parameters:
        E - target element type
        Parameters:
        i - the iterable
        Returns:
        a type-safe iterable containing all elements of the Iterable passed in

      • singleton

        public static <E> Iterable<E> singleton​(E single)
        An iterable containing a single element.
        Type Parameters:
        E - element type
        Parameters:
        single - the element of the iterable to return
        Returns:
        an Iterable returning single once and only once

      • map

        public static <F,​T> Iterable<T> map​(Iterable<F> from,
                                          Mapper<? super F,​T> mapper)
        Create a new iterable by applying a mapper function to each element of a given sequence.
        Type Parameters:
        F - source element type
        T - target element type
        Parameters:
        from - the iterable to transform
        mapper - the function to apply to each element of from
        Returns:
        an iterable where each element is the result of applying the function to an element of the original iterable

      • filter

        public static <T> Iterable<T> filter​(Iterable<T> sequence,
                                     Predicate<? super T> filter)
        Exclude all elements from an iterable that don't match a given predicate.
        Type Parameters:
        T - element type
        Parameters:
        sequence - the iterable to filter
        filter - the predicate to apply
        Returns:
        an iterable containing all elements of the original sequence that match the predicate

      • count

        public static int count​(Iterable seq)
        Count the number of elements in a sequence.
        Parameters:
        seq - the sequence to count
        Returns:
        the number of elements in the sequence

      • any

        public static <T> boolean any​(Iterable<T> sequence,
                              Predicate<? super T> predicate)
        Determines whether a given predicate holds true for at least one element.

        Returns false for an empty sequence.

        Type Parameters:
        T - element type
        Parameters:
        sequence - the sequence to examine
        predicate - the predicate to test
        Returns:
        true if any element of the sequence matches the predicate

      • all

        public static <T> boolean all​(Iterable<T> sequence,
                              Predicate<? super T> predicate)
        Determines whether a given predicate holds true for all elements.

        Returns true for an empty sequence.

        Type Parameters:
        T - element type
        Parameters:
        sequence - the sequence to examine
        predicate - the predicate to test
        Returns:
        true if all elements of the sequence match the predicate