OWLAPIStreamUtils (OWLAPI :: Distribution 5.0.5 API)

java.lang.Object
- org.semanticweb.owlapi.util.OWLAPIStreamUtils

public class OWLAPIStreamUtils
extends Object

A few util methods for common stream operations.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class OWLAPIStreamUtils.Pair<T>
Class for pairwise partition

Nested Classes
Modifier and Type	Class and Description
`static class`	`OWLAPIStreamUtils.Pair<T>` Class for pairwise partition

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> boolean`	`add(Collection<? super T> c, java.util.stream.Stream<T> s)`
`static java.util.stream.Stream<?>`	`allComponents(HasComponents root)`
`static <T> java.util.stream.Stream<OWLAPIStreamUtils.Pair<T>>`	`allPairs(Collection<T> input)`
`static java.util.stream.Stream<int[]>`	`allPairs(int size)`
`static <T> java.util.stream.Stream<OWLAPIStreamUtils.Pair<T>>`	`allPairs(java.util.stream.Stream<T> input)`
`static <T> List<T>`	`asList(java.util.stream.Stream<?> s, Class<T> type)`
`static <T> List<T>`	`asList(java.util.stream.Stream<T> s)`
`static <T> List<T>`	`asListNullsForbidden(java.util.stream.Stream<T> s)`
`static <K,V,Q> Map<K,V>`	`asMap(java.util.stream.Stream<Q> s, java.util.function.Function<Q,K> key, java.util.function.Function<Q,V> val)`
`static <T,Q> Map<T,Q>`	`asMap(java.util.stream.Stream<Q> s, java.util.function.Function<Q,T> f)`
`static <T> Set<T>`	`asSet(java.util.stream.Stream<?> s, Class<T> type)`
`static <T> Set<T>`	`asSet(java.util.stream.Stream<T> s)`
`static <T> Set<T>`	`asUnorderedSet(java.util.stream.Stream<?> s, Class<T> type)`
`static <T> Set<T>`	`asUnorderedSet(java.util.stream.Stream<T> s)`
`static int`	`compareCollections(Collection<? extends OWLObject> set1, Collection<? extends OWLObject> set2)`
`static int`	`compareIterators(Iterator<?> set1, Iterator<?> set2)` Compare iterators element by element (sensitive to order)
`static int`	`compareLists(List<? extends OWLObject> set1, List<? extends OWLObject> set2)` Check lists for equality (sensitive to order)
`static int`	`compareStreams(java.util.stream.Stream<?> set1, java.util.stream.Stream<?> set2)` Compare streams through iterators (sensitive to order)
`static boolean`	`contains(java.util.stream.Stream<?> s, Object o)`
`static <T> java.util.stream.Stream<T>`	`empty()` Annotated wrapper for Stream.empty()
`static boolean`	`equalIterators(Iterator<?> set1, Iterator<?> set2)` Check iterator contents for equality (sensitive to order)
`static boolean`	`equalStreams(java.util.stream.Stream<?> set1, java.util.stream.Stream<?> set2)` Check streams for equality (sensitive to order)
`static java.util.stream.Stream<?>`	`flatComponents(HasComponents root)`
`static <T> OWLAPIStreamUtils.Pair<T>`	`pair(T i, T j)`
`static <T> java.util.stream.Stream<OWLAPIStreamUtils.Pair<T>>`	`pairs(Collection<T> input)`
`static java.util.stream.Stream<int[]>`	`pairs(int size)`
`static <T> java.util.stream.Stream<OWLAPIStreamUtils.Pair<T>>`	`pairs(java.util.stream.Stream<T> input)`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - asSet
```
public static <T> Set<T> asSet(java.util.stream.Stream<T> s)
```
    Parameters:
    
    s - stream to turn to set. The stream is consumed by this operation.
    
    Returns:
    
    set including all elements in the stream
  - asSet
```
public static <T> Set<T> asSet(java.util.stream.Stream<?> s,
                               Class<T> type)
```
    Type Parameters:
    
    T - type of return collection
    
    Parameters:
    
    s - stream to turn to set. The stream is consumed by this operation.
    
    type - force return type to be exactly T
    
    Returns:
    
    set including all elements in the stream
  - asUnorderedSet
```
public static <T> Set<T> asUnorderedSet(java.util.stream.Stream<T> s)
```
    Parameters:
    
    s - stream to turn to set. The stream is consumed by this operation.
    
    Returns:
    
    set including all elements in the stream
  - asUnorderedSet
```
public static <T> Set<T> asUnorderedSet(java.util.stream.Stream<?> s,
                                        Class<T> type)
```
    Type Parameters:
    
    T - type of return collection
    
    Parameters:
    
    s - stream to turn to set. The stream is consumed by this operation.
    
    type - force return type to be exactly T
    
    Returns:
    
    set including all elements in the stream
  - asList
```
public static <T> List<T> asList(java.util.stream.Stream<T> s)
```
    Parameters:
    
    s - stream to turn to list. The stream is consumed by this operation.
    
    Returns:
    
    list including all elements in the stream
  - asListNullsForbidden
```
public static <T> List<T> asListNullsForbidden(java.util.stream.Stream<T> s)
```
    Parameters:
    
    s - stream to turn to list. The stream is consumed by this operation.
    
    Returns:
    
    list including all elements in the stream
  - asList
```
public static <T> List<T> asList(java.util.stream.Stream<?> s,
                                 Class<T> type)
```
    Type Parameters:
    
    T - type of return collection
    
    Parameters:
    
    s - stream to turn to list. The stream is consumed by this operation.
    
    type - force return type to be exactly T
    
    Returns:
    
    list including all elements in the stream
  - asMap
```
public static <T,Q> Map<T,Q> asMap(java.util.stream.Stream<Q> s,
                                   java.util.function.Function<Q,T> f)
```
    Type Parameters:
    
    T - type of key
    
    Q - type of input and value
    
    Parameters:
    
    s - stream to turn to map. The stream is consumed by this operation.
    
    f - function to create the key
    
    Returns:
    
    map including all elements in the stream, keyed by f
  - asMap
```
public static <K,V,Q> Map<K,V> asMap(java.util.stream.Stream<Q> s,
                                     java.util.function.Function<Q,K> key,
                                     java.util.function.Function<Q,V> val)
```
    Type Parameters:
    
    K - type of key
    
    V - type of value
    
    Q - type of input
    
    Parameters:
    
    s - stream to turn to map. The stream is consumed by this operation.
    
    key - function to create the key
    
    val - function to create the value
    
    Returns:
    
    map including all elements in the stream, keyed by key and valued by val
  - contains
```
public static boolean contains(java.util.stream.Stream<?> s,
                               Object o)
```
    Parameters:
    
    s - stream to check for containment. The stream is consumed at least partially by this operation
    
    o - object to search
    
    Returns:
    
    true if the stream contains the object
  - add
```
public static <T> boolean add(Collection<? super T> c,
                              java.util.stream.Stream<T> s)
```
    Parameters:
    
    s - stream of elements to add
    
    c - collection to add to
    
    Returns:
    
    true if any element in the stream is added to the collection
  - compareCollections
```
public static int compareCollections(Collection<? extends OWLObject> set1,
                                     Collection<? extends OWLObject> set2)
```
    Parameters:
    
    set1 - collection to compare
    
    set2 - collection to compare
    
    Returns:
    
    negative value if set1 comes before set2, positive value if set2 comes before set1, 0 if the two sets are equal or incomparable.
  - compareStreams
```
public static int compareStreams(java.util.stream.Stream<?> set1,
                                 java.util.stream.Stream<?> set2)
```
    Compare streams through iterators (sensitive to order)
    
    Parameters:
    
    set1 - stream to compare
    
    set2 - stream to compare
    
    Returns:
    
    negative value if set1 comes before set2, positive value if set2 comes before set1, 0 if the two sets are equal or incomparable.
  - compareIterators
```
public static int compareIterators(Iterator<?> set1,
                                   Iterator<?> set2)
```
    Compare iterators element by element (sensitive to order)
    
    Parameters:
    
    set1 - iterator to compare
    
    set2 - iterator to compare
    
    Returns:
    
    negative value if set1 comes before set2, positive value if set2 comes before set1, 0 if the two sets are equal or incomparable.
  - equalIterators
```
public static boolean equalIterators(Iterator<?> set1,
                                     Iterator<?> set2)
```
    Check iterator contents for equality (sensitive to order)
    
    Parameters:
    
    set1 - iterator to compare
    
    set2 - iterator to compare
    
    Returns:
    
    true if the iterators have the same content, false otherwise.
  - equalStreams
```
public static boolean equalStreams(java.util.stream.Stream<?> set1,
                                   java.util.stream.Stream<?> set2)
```
    Check streams for equality (sensitive to order)
    
    Parameters:
    
    set1 - stream to compare
    
    set2 - stream to compare
    
    Returns:
    
    true if the streams have the same content, false otherwise.
  - compareLists
```
public static int compareLists(List<? extends OWLObject> set1,
                               List<? extends OWLObject> set2)
```
    Check lists for equality (sensitive to order)
    
    Parameters:
    
    set1 - list to compare
    
    set2 - list to compare
    
    Returns:
    
    true if the lists have the same content, false otherwise.
  - empty
```
public static <T> java.util.stream.Stream<T> empty()
```
    Annotated wrapper for Stream.empty()
    
    Returns:
    
    empty stream
  - allComponents
```
public static java.util.stream.Stream<?> allComponents(HasComponents root)
```
    Parameters:
    
    root - the root for the invisit
    
    Returns:
    
    recursive invisit of all components included in the root component; includes the root and all intermediate nodes. Annotations and other groups of elements will be represented as streams or collections, same as if the accessor method on the object was used.
  - flatComponents
```
public static java.util.stream.Stream<?> flatComponents(HasComponents root)
```
    Parameters:
    
    root - the root for the invisit
    
    Returns:
    
    recursive invisit of all components included in the root component; includes the root and all intermediate nodes. Streams will be flattened.
  - pairs
```
public static java.util.stream.Stream<int[]> pairs(int size)
```
    Parameters:
    
    size - size of matrix
    
    Returns:
    
    a stream of coordinates for a triangular matrix of size size. For input 3, the values are (1,2), (1,3), (2,3)
  - allPairs
```
public static java.util.stream.Stream<int[]> allPairs(int size)
```
    Parameters:
    
    size - size of matrix
    
    Returns:
    
    a stream of coordinates for a symmetric matrix of size size, excluding main diagonal. For input 3, the values are (1,2), (1,3), (2,3), (2,1),(3,1), (3,2)
  - pairs
```
public static <T> java.util.stream.Stream<OWLAPIStreamUtils.Pair<T>> pairs(Collection<T> input)
```
    Parameters:
    
    input - collection to partition
    
    Returns:
    
    a stream of elements for a triangular matrix of size l.size(), where l is the list corresponding to the input collection. For input of length 3, the values are (l.get(1),l.get(2)), (l.get(1),l.get(3)), (l.get(2),l.get(3))
  - allPairs
```
public static <T> java.util.stream.Stream<OWLAPIStreamUtils.Pair<T>> allPairs(Collection<T> input)
```
    Parameters:
    
    input - collection to partition
    
    Returns:
    
    a stream of coordinates for a symmetric matrix of size l.size(), where l is the list corresponding to the input collection, excluding main diagonal. For input 3, the values are (l.get(1),l.get(2)), (l.get(1),l.get(3)), (l.get(2),l.get(3)), (l.get(2),l.get(1)),(l.get(3),l.get(1)), (l.get(3),l.get(2))
  - pairs
```
public static <T> java.util.stream.Stream<OWLAPIStreamUtils.Pair<T>> pairs(java.util.stream.Stream<T> input)
```
    Parameters:
    
    input - collection to partition
    
    Returns:
    
    a stream of elements for a triangular matrix of size l.size(), where l is the list corresponding to the input collection. For input of length 3, the values are (l.get(1),l.get(2)), (l.get(1),l.get(3)), (l.get(2),l.get(3))
  - allPairs
```
public static <T> java.util.stream.Stream<OWLAPIStreamUtils.Pair<T>> allPairs(java.util.stream.Stream<T> input)
```
    Parameters:
    
    input - collection to partition
    
    Returns:
    
    a stream of coordinates for a symmetric matrix of size l.size(), where l is the list corresponding to the input collection, excluding main diagonal. For input 3, the values are (l.get(1),l.get(2)), (l.get(1),l.get(3)), (l.get(2),l.get(3)), (l.get(2),l.get(1)),(l.get(3),l.get(1)), (l.get(3),l.get(2))
  - pair
```
public static <T> OWLAPIStreamUtils.Pair<T> pair(T i,
                                                 T j)
```
    Parameters:
    
    i - first
    
    j - second
    
    Returns:
    
    pair of (i,j)

Class OWLAPIStreamUtils

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

asSet

asSet

asUnorderedSet

asUnorderedSet

asList

asListNullsForbidden

asList

asMap

asMap

contains

add

compareCollections

compareStreams

compareIterators

equalIterators

equalStreams

compareLists

empty

allComponents

flatComponents

pairs

allPairs

pairs

allPairs

pairs

allPairs

pair