org.apache.sshd.common.util

Class GenericUtils

java.lang.Object

org.apache.sshd.common.util.GenericUtils

public final class GenericUtils
extends Object

Author:

Apache MINA SSHD Project

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	GenericUtils.MapBuilder<K,V>

Field Summary

Fields

Modifier and Type	Field and Description
static Comparator<String>	CASE_SENSITIVE_ORDER The complement of String.CASE_INSENSITIVE_ORDER
static byte[]	EMPTY_BYTE_ARRAY
static char[]	EMPTY_CHAR_ARRAY
static Object[]	EMPTY_OBJECT_ARRAY
static String[]	EMPTY_STRING_ARRAY
static Object	NULL A value indicating a null value - to be used as a placeholder where nulls are not allowed
static String	QUOTES

Method Summary

Modifier and Type	Method and Description
static <T extends Throwable> T	accumulateException(T current, T extra) Used to "accumulate" exceptions of the same type.
static <T> List<T>	asList(T... values)
static <T> Set<T>	asSet(T... values)
static <V extends Comparable<V>> SortedSet<V>	asSortedSet(Collection<? extends V> values)
static <V> SortedSet<V>	asSortedSet(Comparator<? super V> comp, Collection<? extends V> values)
static <V> SortedSet<V>	asSortedSet(Comparator<? super V> comp, V... values)
static <V extends Comparable<V>> SortedSet<V>	asSortedSet(V... values)
static <V> Supplier<SortedMap<String,V>>	caseInsensitiveMap()
static int	compare(char[] c1, char[] c2) Compares 2 character arrays - Note: null and empty are considered equal
static <T> boolean	containsAny(Collection<? extends T> coll, Iterable<? extends T> values)
static <T> T	findFirstMatchingMember(Predicate<? super T> acceptor, Collection<? extends T> values)
static <T> T	findFirstMatchingMember(Predicate<? super T> acceptor, T... values)
static <K,V> Map<V,K>	flipMap(Map<? extends K,? extends V> map, Supplier<? extends Map<V,K>> mapCreator, boolean allowDuplicates)
static <T> void	forEach(Iterable<T> values, Consumer<T> consumer)
static int	hashCode(String s)
static int	hashCode(String s, Boolean useUppercase)
static int	indexOf(CharSequence cs, char c)
static boolean	isEmpty(char[] chars)
static boolean	isEmpty(CharSequence cs)
static boolean	isEmpty(Collection<?> c)
static <T> boolean	isEmpty(Iterable<? extends T> iter)
static <T> boolean	isEmpty(Iterator<? extends T> iter)
static boolean	isEmpty(Map<?,?> m)
static <T> boolean	isEmpty(T... a)
static boolean	isNotEmpty(CharSequence cs)
static boolean	isNotEmpty(Collection<?> c)
static <T> boolean	isNotEmpty(Iterable<? extends T> iter)
static <T> boolean	isNotEmpty(Iterator<? extends T> iter)
static boolean	isNotEmpty(Map<?,?> m)
static <T> boolean	isSameReference(T o1, T o2)
static <T> Iterator<T>	iteratorOf(Iterable<T> iterable) Resolves to an always non-null iterator
static <T> Iterator<T>	iteratorOf(Iterator<T> iter) Resolves to an always non-null iterator
static String	join(Iterable<?> iter, char ch)
static String	join(Iterable<?> iter, CharSequence sep)
static String	join(Iterator<?> iter, char ch)
static String	join(Iterator<?> iter, CharSequence sep)
static <T> String	join(T[] values, char ch)
static <T> String	join(T[] values, CharSequence sep)
static int	lastIndexOf(CharSequence cs, char c)
static int	length(char[] chars)
static int	length(CharSequence cs)
static <T> int	length(T... a)
static <T,U> List<U>	map(Collection<T> values, Function<? super T,? extends U> mapper)
static <K,V> GenericUtils.MapBuilder<K,V>	mapBuilder()
static <K,V> GenericUtils.MapBuilder<K,V>	mapBuilder(Comparator<K> comparator)
static <T,U> SortedSet<U>	mapSort(Collection<T> values, Function<? super T,? extends U> mapper, Comparator<U> comparator)
static <K,V> Map<K,V>	mapValues(Function<? super V,? extends K> keyMapper, Supplier<? extends Map<K,V>> mapCreator, Collection<V> values) Creates a map out of a group of values
static <K,V> Map<K,V>	mapValues(Function<? super V,? extends K> keyMapper, Supplier<? extends Map<K,V>> mapCreator, V... values)
static <T> Iterable<T>	multiIterableSuppliers(Iterable<? extends Supplier<? extends Iterable<? extends T>>> providers) Wraps a group of Suppliers of Iterable instances into a "unified" Iterable of their values, in the same order as the suppliers - i.e., once the values from a specific supplier are exhausted, the next one is consulted, and so on, until all suppliers have been consulted
static <E extends Enum<E>> Set<E>	of(Collection<? extends E> values)
static <E extends Enum<E>> Set<E>	of(E... values)
static Throwable	peelException(Throwable t) Attempts to get to the "effective" exception being thrown, by taking care of some known exceptions that wrap the original thrown one.
static String	replaceWhitespaceAndTrim(String s)
static Throwable	resolveExceptionCause(Throwable t)
static int	safeCompare(String s1, String s2, boolean caseSensitive)
static <T> List<T>	selectMatchingMembers(Predicate<? super T> acceptor, Collection<? extends T> values) Returns a list of all the values that were accepted by a predicate
static <T> List<T>	selectMatchingMembers(Predicate<? super T> acceptor, T... values) Returns a list of all the values that were accepted by a predicate
static int	size(Collection<?> c)
static int	size(Map<?,?> m)
static String[]	split(String s, char ch)
static <T> Stream<T>	stream(Iterable<T> values)
static CharSequence	stripDelimiters(CharSequence s, char delim)
static CharSequence	stripQuotes(CharSequence s)
static <T> Supplier<T>	supplierOf(T value) Wraps a value into a Supplier
static IOException	toIOException(Throwable e)
static RuntimeException	toRuntimeException(Throwable t)
static RuntimeException	toRuntimeException(Throwable t, boolean peelThrowable) Converts a thrown generic exception to a RuntimeException
static <T,K,U> Collector<T,?,SortedMap<K,U>>	toSortedMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, Comparator<K> comparator)
static <T,K,U> SortedMap<K,U>	toSortedMap(Iterable<T> values, Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, Comparator<K> comparator)
static <T> Collector<T,?,SortedSet<T>>	toSortedSet(Comparator<T> comparator)
static String	trimToEmpty(String s)
static <T> List<T>	unmodifiableList(Collection<? extends T> values)
static <T> List<T>	unmodifiableList(Stream<T> values)
static <T> List<T>	unmodifiableList(T... values)
static <U,V> Iterable<V>	wrapIterable(Iterable<? extends U> iter, Function<U,V> mapper)
static <U,V> Iterator<V>	wrapIterator(Iterable<? extends U> iter, Function<U,V> mapper)
static <U,V> Iterator<V>	wrapIterator(Iterator<? extends U> iter, Function<U,V> mapper)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

EMPTY_BYTE_ARRAY

public static final byte[] EMPTY_BYTE_ARRAY

EMPTY_CHAR_ARRAY

public static final char[] EMPTY_CHAR_ARRAY

EMPTY_STRING_ARRAY

public static final String[] EMPTY_STRING_ARRAY

EMPTY_OBJECT_ARRAY

public static final Object[] EMPTY_OBJECT_ARRAY

NULL

public static final Object NULL

A value indicating a null value - to be used as a placeholder where nulls are not allowed

CASE_SENSITIVE_ORDER

public static final Comparator<String> CASE_SENSITIVE_ORDER

The complement of String.CASE_INSENSITIVE_ORDER

QUOTES

public static final String QUOTES

See Also:

Constant Field Values

Method Detail

trimToEmpty

public static String trimToEmpty(String s)

replaceWhitespaceAndTrim

public static String replaceWhitespaceAndTrim(String s)

hashCode

public static int hashCode(String s)

Parameters:

s - The String value to calculate the hash code on - may be null/empty in which case a value of zero is returned

Returns:

The calculated hash code

See Also:

hashCode(String, Boolean)

hashCode

public static int hashCode(String s,
                           Boolean useUppercase)

Parameters:

s - The String value to calculate the hash code on - may be null/empty in which case a value of zero is returned

useUppercase - Whether to convert the string to uppercase, lowercase or not at all:

• null - no conversion
• Boolean.TRUE - get hash code of uppercase
• Boolean.FALSE - get hash code of lowercase

Returns:

The calculated hash code

safeCompare

public static int safeCompare(String s1,
                              String s2,
                              boolean caseSensitive)

isSameReference

public static <T> boolean isSameReference(T o1,
                                          T o2)

length

public static int length(CharSequence cs)

isEmpty

public static boolean isEmpty(CharSequence cs)

isNotEmpty

public static boolean isNotEmpty(CharSequence cs)

indexOf

public static int indexOf(CharSequence cs,
                          char c)

lastIndexOf

public static int lastIndexOf(CharSequence cs,
                              char c)

split

public static String[] split(String s,
                             char ch)

join

public static <T> String join(T[] values,
                              char ch)

join

public static String join(Iterable<?> iter,
                          char ch)

join

public static String join(Iterator<?> iter,
                          char ch)

join

public static <T> String join(T[] values,
                              CharSequence sep)

join

public static String join(Iterable<?> iter,
                          CharSequence sep)

join

public static String join(Iterator<?> iter,
                          CharSequence sep)

size

public static int size(Collection<?> c)

isEmpty

public static boolean isEmpty(Collection<?> c)

isNotEmpty

public static boolean isNotEmpty(Collection<?> c)

size

public static int size(Map<?,?> m)

isEmpty

public static boolean isEmpty(Map<?,?> m)

isNotEmpty

public static boolean isNotEmpty(Map<?,?> m)

length

@SafeVarargs
public static <T> int length(T... a)

isEmpty

public static <T> boolean isEmpty(Iterable<? extends T> iter)

isNotEmpty

public static <T> boolean isNotEmpty(Iterable<? extends T> iter)

isEmpty

public static <T> boolean isEmpty(Iterator<? extends T> iter)

isNotEmpty

public static <T> boolean isNotEmpty(Iterator<? extends T> iter)

isEmpty

@SafeVarargs
public static <T> boolean isEmpty(T... a)

length

public static int length(char[] chars)

isEmpty

public static boolean isEmpty(char[] chars)

compare

public static int compare(char[] c1,
                          char[] c2)

Compares 2 character arrays - Note: null and empty are considered equal

Parameters:

c1 - 1st array

c2 - 2nd array

Returns:

Negative is 1st array comes first in lexicographical order, positive if 2nd array comes first and zero if equal

of

@SafeVarargs
public static <E extends Enum<E>> Set<E> of(E... values)

of

public static <E extends Enum<E>> Set<E> of(Collection<? extends E> values)

containsAny

public static <T> boolean containsAny(Collection<? extends T> coll,
                                      Iterable<? extends T> values)

forEach

public static <T> void forEach(Iterable<T> values,
                               Consumer<T> consumer)

map

public static <T,U> List<U> map(Collection<T> values,
                                Function<? super T,? extends U> mapper)

mapSort

public static <T,U> SortedSet<U> mapSort(Collection<T> values,
                                         Function<? super T,? extends U> mapper,
                                         Comparator<U> comparator)

toSortedMap

public static <T,K,U> SortedMap<K,U> toSortedMap(Iterable<T> values,
                                                 Function<? super T,? extends K> keyMapper,
                                                 Function<? super T,? extends U> valueMapper,
                                                 Comparator<K> comparator)

toSortedMap

public static <T,K,U> Collector<T,?,SortedMap<K,U>> toSortedMap(Function<? super T,? extends K> keyMapper,
                                                                Function<? super T,? extends U> valueMapper,
                                                                Comparator<K> comparator)

toSortedSet

public static <T> Collector<T,?,SortedSet<T>> toSortedSet(Comparator<T> comparator)

stream

public static <T> Stream<T> stream(Iterable<T> values)

unmodifiableList

@SafeVarargs
public static <T> List<T> unmodifiableList(T... values)

unmodifiableList

public static <T> List<T> unmodifiableList(Collection<? extends T> values)

unmodifiableList

public static <T> List<T> unmodifiableList(Stream<T> values)

asList

@SafeVarargs
public static <T> List<T> asList(T... values)

asSet

@SafeVarargs
public static <T> Set<T> asSet(T... values)

asSortedSet

@SafeVarargs
public static <V extends Comparable<V>> SortedSet<V> asSortedSet(V... values)

asSortedSet

public static <V extends Comparable<V>> SortedSet<V> asSortedSet(Collection<? extends V> values)

asSortedSet

@SafeVarargs
public static <V> SortedSet<V> asSortedSet(Comparator<? super V> comp,
                                                        V... values)

Type Parameters:

V - The element type

Parameters:

comp - The (non-null) Comparator to use

values - The values to be added (ignored if null)

Returns:

A SortedSet containing the values (if any) sorted using the provided comparator

asSortedSet

public static <V> SortedSet<V> asSortedSet(Comparator<? super V> comp,
                                           Collection<? extends V> values)

Type Parameters:

V - The element type

Parameters:

comp - The (non-null) Comparator to use

values - The values to be added (ignored if null/empty)

Returns:

A SortedSet containing the values (if any) sorted using the provided comparator

caseInsensitiveMap

public static <V> Supplier<SortedMap<String,V>> caseInsensitiveMap()

Type Parameters:

V - Type of mapped value

Returns:

A Supplier that returns a new SortedMap whenever its get() method is invoked

flipMap

public static <K,V> Map<V,K> flipMap(Map<? extends K,? extends V> map,
                                     Supplier<? extends Map<V,K>> mapCreator,
                                     boolean allowDuplicates)

mapValues

@SafeVarargs
public static <K,V> Map<K,V> mapValues(Function<? super V,? extends K> keyMapper,
                                                    Supplier<? extends Map<K,V>> mapCreator,
                                                    V... values)

mapValues

public static <K,V> Map<K,V> mapValues(Function<? super V,? extends K> keyMapper,
                                       Supplier<? extends Map<K,V>> mapCreator,
                                       Collection<V> values)

Creates a map out of a group of values

Type Parameters:

K - The key type

V - The value type

Parameters:

keyMapper - The Function that generates a key for a given value. If the returned key is null then the value is not mapped

mapCreator - The Supplier used to create/retrieve the result map - provided non-empty group of values

values - The values to be mapped

Returns:

The resulting Map - Note: no validation is made to ensure that 2 (or more) values are not mapped to the same key

findFirstMatchingMember

@SafeVarargs
public static <T> T findFirstMatchingMember(Predicate<? super T> acceptor,
                                                         T... values)

findFirstMatchingMember

public static <T> T findFirstMatchingMember(Predicate<? super T> acceptor,
                                            Collection<? extends T> values)

selectMatchingMembers

@SafeVarargs
public static <T> List<T> selectMatchingMembers(Predicate<? super T> acceptor,
                                                             T... values)

Returns a list of all the values that were accepted by a predicate

Type Parameters:

T - The type of value being evaluated

Parameters:

acceptor - The Predicate to consult whether a member is selected

values - The values to be scanned

Returns:

A List of all the values that were accepted by the predicate

selectMatchingMembers

public static <T> List<T> selectMatchingMembers(Predicate<? super T> acceptor,
                                                Collection<? extends T> values)

Returns a list of all the values that were accepted by a predicate

Type Parameters:

T - The type of value being evaluated

Parameters:

acceptor - The Predicate to consult whether a member is selected

values - The values to be scanned

Returns:

A List of all the values that were accepted by the predicate

stripQuotes

public static CharSequence stripQuotes(CharSequence s)

Parameters:

s - The CharSequence to be checked

Returns:

If the sequence contains any of the QUOTES on both ends, then they are stripped, otherwise nothing is done

See Also:

stripDelimiters(CharSequence, char)

stripDelimiters

public static CharSequence stripDelimiters(CharSequence s,
                                           char delim)

Parameters:

s - The CharSequence to be checked

delim - The expected delimiter

Returns:

If the sequence contains the delimiter on both ends, then it is are stripped, otherwise nothing is done

toRuntimeException

public static RuntimeException toRuntimeException(Throwable t)

toRuntimeException

public static RuntimeException toRuntimeException(Throwable t,
                                                  boolean peelThrowable)

Converts a thrown generic exception to a RuntimeException

Parameters:

t - The original thrown exception

peelThrowable - Whether to determine the root cause by "peeling" any enclosing exceptions

Returns:

The thrown cause if already a runtime exception, otherwise a runtime exception of the resolved exception as its cause

See Also:

peelException(Throwable)

peelException

public static Throwable peelException(Throwable t)

Attempts to get to the "effective" exception being thrown, by taking care of some known exceptions that wrap the original thrown one.

Parameters:

t - The original Throwable - ignored if null

Returns:

The effective exception - same as input if not a wrapper

resolveExceptionCause

public static Throwable resolveExceptionCause(Throwable t)

Parameters:

t - The original Throwable - ignored if null

Returns:

If Throwable.getCause() is non-null then the cause, otherwise the original exception - null if the original exception was null

accumulateException

public static <T extends Throwable> T accumulateException(T current,
                                                          T extra)

Used to "accumulate" exceptions of the same type. If the current exception is null then the new one becomes the current, otherwise the new one is added as a suppressed exception to the current one

Type Parameters:

T - The exception type

Parameters:

current - The current exception

extra - The extra/new exception

Returns:

The resolved exception

See Also:

Throwable.addSuppressed(Throwable)

toIOException

public static IOException toIOException(Throwable e)

supplierOf

public static <T> Supplier<T> supplierOf(T value)

Wraps a value into a Supplier

Type Parameters:

T - Type of value being supplied

Parameters:

value - The value to be supplied

Returns:

The supplier wrapper

iteratorOf

public static <T> Iterator<T> iteratorOf(Iterable<T> iterable)

Resolves to an always non-null iterator

Type Parameters:

T - Type of value being iterated

Parameters:

iterable - The Iterable instance

Returns:

A non-null iterator which may be empty if no iterable instance or no iterator returned from it

See Also:

iteratorOf(Iterator)

iteratorOf

public static <T> Iterator<T> iteratorOf(Iterator<T> iter)

Resolves to an always non-null iterator

Type Parameters:

T - Type of value being iterated

Parameters:

iter - The Iterator instance

Returns:

A non-null iterator which may be empty if no iterator instance

See Also:

Collections.emptyIterator()

wrapIterable

public static <U,V> Iterable<V> wrapIterable(Iterable<? extends U> iter,
                                             Function<U,V> mapper)

wrapIterator

public static <U,V> Iterator<V> wrapIterator(Iterable<? extends U> iter,
                                             Function<U,V> mapper)

wrapIterator

public static <U,V> Iterator<V> wrapIterator(Iterator<? extends U> iter,
                                             Function<U,V> mapper)

multiIterableSuppliers

public static <T> Iterable<T> multiIterableSuppliers(Iterable<? extends Supplier<? extends Iterable<? extends T>>> providers)

Wraps a group of Suppliers of Iterable instances into a "unified" Iterable of their values, in the same order as the suppliers - i.e., once the values from a specific supplier are exhausted, the next one is consulted, and so on, until all suppliers have been consulted

Type Parameters:

T - Type of value being iterated

Parameters:

providers - The providers - ignored if null (i.e., return an empty iterable instance)

Returns:

The wrapping instance

mapBuilder

public static <K,V> GenericUtils.MapBuilder<K,V> mapBuilder()

mapBuilder

public static <K,V> GenericUtils.MapBuilder<K,V> mapBuilder(Comparator<K> comparator)