de.caff.generics

Class TypesImplMap

java.lang.Object

de.caff.generics.TypesImplMap

final class TypesImplMap
extends java.lang.Object

Partial class used by Types, defining the map algorithms.

Author:

Rammi

Method Summary

Modifier and Type	Method and Description
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapEImpl(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an enumeration into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapEImpl(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapEImpl(C target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an iterator into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapEImpl(C target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iterator into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapImpl(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapImpl(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapImpl(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iterator into a collection.
(package private) static <C extends java.util.function.Consumer<? super T>,T,S> C	mapImpl(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iterator to a consumer.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapImpl(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a collection.
(package private) static <C extends java.util.function.Consumer<? super T>,T,S> C	mapImpl(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Forward the mapped elements of an iterator to a consumer.
(package private) static <MT extends java.util.Map<? super KT,? super VT>,KT,VT,KS,VS> MT	mapImpl(MT target, java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<KS,VS>,? extends java.util.Map.Entry<KT,VT>> typeConverter) Map one map into another, while allowing to discard elements on the way.
(package private) static <M extends java.util.Map<? super T,? super S>,T,S> M	mapMEImpl(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an enumeration to a map.
(package private) static <M extends java.util.Map<? super T,? super S>,T,S> M	mapMEImpl(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an enumeration to a map.
(package private) static <M extends java.util.Map<? super T,? super S>,T,S> M	mapMEImpl(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an iterator to a map.
(package private) static <M extends java.util.Map<? super T,? super S>,T,S> M	mapMEImpl(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
(package private) static <M extends java.util.Map<? super T,? super S>,T,S> M	mapMImpl(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a collection.
(package private) static <M extends java.util.Map<? super T,? super S>,T,S> M	mapMImpl(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a map.
(package private) static <M extends java.util.Map<? super T,? super S>,T,S> M	mapMImpl(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iterator into a map.
(package private) static <M extends java.util.Map<? super T,? super S>,T,S> M	mapMImpl(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
(package private) static <M extends java.util.Map<? super S,? super T>,T,S> M	mapREImpl(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an enumeration to a map.
(package private) static <M extends java.util.Map<? super S,? super T>,T,S> M	mapREImpl(M target, java.util.Enumeration<S> enumeration, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an enumeration to a map.
(package private) static <M extends java.util.Map<? super S,? super T>,T,S> M	mapREImpl(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter) Add the mapped elements of an iterator to a map.
(package private) static <M extends java.util.Map<? super S,? super T>,T,S> M	mapREImpl(M target, java.util.Iterator<S> iterator, FragileTypeConverter<T,? super S> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
(package private) static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRImpl(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an enumeration into a collection.
(package private) static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRImpl(M target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an enumeration into a map.
(package private) static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRImpl(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter) Add the mapped elements of an iterator into a map.
(package private) static <M extends java.util.Map<? super S,? super T>,T,S> M	mapRImpl(M target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,T> typeConverter, T deleteMark) Add the mapped elements of an iterator into a map.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapXEImpl(C target, java.util.Enumeration<S> enumeration, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Add the mapped elements of an enumeration into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapXEImpl(C target, java.util.Iterator<S> iterator, FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter) Add the mapped elements of an iterator into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapXImpl(C target, java.util.Enumeration<S> enumeration, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Add the mapped elements of an enumeration into a collection.
(package private) static <C extends java.util.Collection<? super T>,T,S> C	mapXImpl(C target, java.util.Iterator<S> iterator, java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter) Add the mapped elements of an iterator into a collection.
(package private) static <MT extends java.util.Map<? super KT,? super VT>,KT,VT,KS,VS> MT	mapXImpl(MT target, java.util.Map<KS,VS> source, java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,? extends java.lang.Iterable<? extends java.util.Map.Entry<? extends KT,? extends VT>>> typeConverter) Map one map into another, allowing to discard or add elements on the way.

Methods inherited from class java.lang.Object

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

Method Detail

mapImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapImpl(@NotNull
                                                                          C target,
                                                                          @NotNull
                                                                          java.util.Iterator<S> iterator,
                                                                          @NotNull
                                                                          java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iterator into a collection.

This will add all mapped elements to the target collection. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See Types.map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapImpl

@NotNull
static <C extends java.util.function.Consumer<? super T>,T,S> C mapImpl(@NotNull
                                                                                 C target,
                                                                                 @NotNull
                                                                                 java.util.Iterator<S> iterator,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iterator to a consumer.

This will add all mapped elements to the consumer. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - consumer where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapMImpl

@NotNull
static <M extends java.util.Map<? super T,? super S>,T,S> M mapMImpl(@NotNull
                                                                              M target,
                                                                              @NotNull
                                                                              java.util.Iterator<S> iterator,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iterator into a map.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapRImpl

@NotNull
static <M extends java.util.Map<? super S,? super T>,T,S> M mapRImpl(@NotNull
                                                                              M target,
                                                                              @NotNull
                                                                              java.util.Iterator<S> iterator,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an iterator into a map.

This will add all mapped elements to the target collection, using the incoming values as keys pointing to the converted values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapImpl(@NotNull
                                                                          C target,
                                                                          @NotNull
                                                                          java.util.Enumeration<S> enumeration,
                                                                          @NotNull
                                                                          java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See Types.map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapMImpl

@NotNull
static <M extends java.util.Map<? super T,? super S>,T,S> M mapMImpl(@NotNull
                                                                              M target,
                                                                              @NotNull
                                                                              java.util.Enumeration<S> enumeration,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapRImpl

@NotNull
static <M extends java.util.Map<? super S,? super T>,T,S> M mapRImpl(@NotNull
                                                                              M target,
                                                                              @NotNull
                                                                              java.util.Enumeration<S> enumeration,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> typeConverter)

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection, using the converted values as keys pointing to the incoming values.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapImpl

@NotNull
static <MT extends java.util.Map<? super KT,? super VT>,KT,VT,KS,VS> MT mapImpl(@NotNull
                                                                                         MT target,
                                                                                         @NotNull
                                                                                         java.util.Map<KS,VS> source,
                                                                                         @NotNull
                                                                                         java.util.function.Function<java.util.Map.Entry<KS,VS>,? extends java.util.Map.Entry<KT,VT>> typeConverter)

Map one map into another, while allowing to discard elements on the way.

An element is discarded if the type converter returns null.

Type Parameters:

MT - target map type

KT - target map key type

VT - target map value type

KS - source map key type

VS - source map value type

Parameters:

target - target map

source - source map

typeConverter - type converter converting map entries

Returns:

target map

mapXImpl

@NotNull
static <MT extends java.util.Map<? super KT,? super VT>,KT,VT,KS,VS> MT mapXImpl(@NotNull
                                                                                          MT target,
                                                                                          @NotNull
                                                                                          java.util.Map<KS,VS> source,
                                                                                          @NotNull
                                                                                          java.util.function.Function<java.util.Map.Entry<? super KS,? super VS>,? extends java.lang.Iterable<? extends java.util.Map.Entry<? extends KT,? extends VT>>> typeConverter)

Map one map into another, allowing to discard or add elements on the way.

Type Parameters:

MT - target map type

KT - target map key type

VT - target map value type

KS - source map key type

VS - source map value type

Parameters:

target - target map

source - source map

typeConverter - type converter converting map entries

Returns:

target map

mapXImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapXImpl(@NotNull
                                                                           C target,
                                                                           @NotNull
                                                                           java.util.Iterator<S> iterator,
                                                                           @NotNull
                                                                           java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Add the mapped elements of an iterator into a collection.

This will add all mapped elements to the target collection. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See Types.map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapXImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapXImpl(@NotNull
                                                                           C target,
                                                                           @NotNull
                                                                           java.util.Enumeration<S> enumeration,
                                                                           @NotNull
                                                                           java.util.function.Function<? super S,? extends java.lang.Iterable<T>> typeConverter)

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See Types.map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

mapImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapImpl(@NotNull
                                                                          C target,
                                                                          @NotNull
                                                                          java.util.Iterator<S> iterator,
                                                                          @NotNull
                                                                          java.util.function.Function<? super S,T> typeConverter,
                                                                          @Nullable
                                                                          T deleteMark)

Add the mapped elements of an iterator into a collection.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapImpl

@NotNull
static <C extends java.util.function.Consumer<? super T>,T,S> C mapImpl(@NotNull
                                                                                 C target,
                                                                                 @NotNull
                                                                                 java.util.Iterator<S> iterator,
                                                                                 @NotNull
                                                                                 java.util.function.Function<? super S,T> typeConverter,
                                                                                 @Nullable
                                                                                 T deleteMark)

Forward the mapped elements of an iterator to a consumer.

This method allows to discard elements during the mapping.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - consumer to which each element is mapped

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapMImpl

@NotNull
static <M extends java.util.Map<? super T,? super S>,T,S> M mapMImpl(@NotNull
                                                                              M target,
                                                                              @NotNull
                                                                              java.util.Iterator<S> iterator,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> typeConverter,
                                                                              @Nullable
                                                                              T deleteMark)

Add the mapped elements of an iterator into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapRImpl

@NotNull
static <M extends java.util.Map<? super S,? super T>,T,S> M mapRImpl(@NotNull
                                                                              M target,
                                                                              @NotNull
                                                                              java.util.Iterator<S> iterator,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> typeConverter,
                                                                              @Nullable
                                                                              T deleteMark)

Add the mapped elements of an iterator into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapImpl(@NotNull
                                                                          C target,
                                                                          @NotNull
                                                                          java.util.Enumeration<S> enumeration,
                                                                          @NotNull
                                                                          java.util.function.Function<? super S,T> typeConverter,
                                                                          @Nullable
                                                                          T deleteMark)

Add the mapped elements of an enumeration into a collection.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapMImpl

@NotNull
static <M extends java.util.Map<? super T,? super S>,T,S> M mapMImpl(@NotNull
                                                                              M target,
                                                                              @NotNull
                                                                              java.util.Enumeration<S> enumeration,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> typeConverter,
                                                                              @Nullable
                                                                              T deleteMark)

Add the mapped elements of an enumeration into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapRImpl

@NotNull
static <M extends java.util.Map<? super S,? super T>,T,S> M mapRImpl(@NotNull
                                                                              M target,
                                                                              @NotNull
                                                                              java.util.Enumeration<S> enumeration,
                                                                              @NotNull
                                                                              java.util.function.Function<? super S,T> typeConverter,
                                                                              @Nullable
                                                                              T deleteMark)

Add the mapped elements of an enumeration into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

mapEImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapEImpl(@NotNull
                                                                           C target,
                                                                           @NotNull
                                                                           java.util.Iterator<S> iterator,
                                                                           @NotNull
                                                                           FragileTypeConverter<T,? super S> typeConverter)
                                                                    throws TypeConverterException

Add the mapped elements of an iterator into a collection.

This will add all mapped elements to the target collection. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See Types.map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapMEImpl

@NotNull
static <M extends java.util.Map<? super T,? super S>,T,S> M mapMEImpl(@NotNull
                                                                               M target,
                                                                               @NotNull
                                                                               java.util.Iterator<S> iterator,
                                                                               @NotNull
                                                                               FragileTypeConverter<T,? super S> typeConverter)
                                                                        throws TypeConverterException

Add the mapped elements of an iterator to a map.

The converted values will become keys, pointing to the associated incoming values.

This will add all mapped elements to the target map. See Types.mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See Types.map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapREImpl

@NotNull
static <M extends java.util.Map<? super S,? super T>,T,S> M mapREImpl(@NotNull
                                                                               M target,
                                                                               @NotNull
                                                                               java.util.Iterator<S> iterator,
                                                                               @NotNull
                                                                               FragileTypeConverter<T,? super S> typeConverter)
                                                                        throws TypeConverterException

Add the mapped elements of an iterator to a map.

The incoming values will become keys, pointing to the associated converted values.

This will add all mapped elements to the target map. See Types.mapR(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapEImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapEImpl(@NotNull
                                                                           C target,
                                                                           @NotNull
                                                                           java.util.Enumeration<S> enumeration,
                                                                           @NotNull
                                                                           FragileTypeConverter<T,? super S> typeConverter)
                                                                    throws TypeConverterException

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapMEImpl

@NotNull
static <M extends java.util.Map<? super T,? super S>,T,S> M mapMEImpl(@NotNull
                                                                               M target,
                                                                               @NotNull
                                                                               java.util.Enumeration<S> enumeration,
                                                                               @NotNull
                                                                               FragileTypeConverter<T,? super S> typeConverter)
                                                                        throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The converted values will become keys, pointing to the associated incoming values.

This will add all mapped elements to the target map. See Types.mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapREImpl

@NotNull
static <M extends java.util.Map<? super S,? super T>,T,S> M mapREImpl(@NotNull
                                                                               M target,
                                                                               @NotNull
                                                                               java.util.Enumeration<S> enumeration,
                                                                               @NotNull
                                                                               FragileTypeConverter<T,? super S> typeConverter)
                                                                        throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The incoming values will become keys, pointing to the associated converted values.

This will add all mapped elements to the target map. See Types.mapM(java.util.Map, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXEImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapXEImpl(@NotNull
                                                                            C target,
                                                                            @NotNull
                                                                            java.util.Iterator<S> iterator,
                                                                            @NotNull
                                                                            FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                     throws TypeConverterException

Add the mapped elements of an iterator into a collection.

This will add all mapped elements to the target collection. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

See Types.map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapXEImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapXEImpl(@NotNull
                                                                            C target,
                                                                            @NotNull
                                                                            java.util.Enumeration<S> enumeration,
                                                                            @NotNull
                                                                            FragileTypeConverter<? extends java.lang.Iterable<T>,? super S> typeConverter)
                                                                     throws TypeConverterException

Add the mapped elements of an enumeration into a collection.

This will add all mapped elements to the target collection. See Types.map(java.util.Collection, Iterable, Function, Object) for a method which allows to discard elements.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

See Types.map(java.util.Collection, Iterable, Function) for an easy to adapt example.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapEImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapEImpl(@NotNull
                                                                           C target,
                                                                           @NotNull
                                                                           java.util.Iterator<S> iterator,
                                                                           @NotNull
                                                                           FragileTypeConverter<T,? super S> typeConverter,
                                                                           @Nullable
                                                                           T deleteMark)
                                                                    throws TypeConverterException

Add the mapped elements of an iterator into a collection.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapMEImpl

@NotNull
static <M extends java.util.Map<? super T,? super S>,T,S> M mapMEImpl(@NotNull
                                                                               M target,
                                                                               @NotNull
                                                                               java.util.Iterator<S> iterator,
                                                                               @NotNull
                                                                               FragileTypeConverter<T,? super S> typeConverter,
                                                                               @Nullable
                                                                               T deleteMark)
                                                                        throws TypeConverterException

Add the mapped elements of an iterator into a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapREImpl

@NotNull
static <M extends java.util.Map<? super S,? super T>,T,S> M mapREImpl(@NotNull
                                                                               M target,
                                                                               @NotNull
                                                                               java.util.Iterator<S> iterator,
                                                                               @NotNull
                                                                               FragileTypeConverter<T,? super S> typeConverter,
                                                                               @Nullable
                                                                               T deleteMark)
                                                                        throws TypeConverterException

Add the mapped elements of an iterator into a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that iterator is not allowed to be an iterator of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

iterator - iterator providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapEImpl

@NotNull
static <C extends java.util.Collection<? super T>,T,S> C mapEImpl(@NotNull
                                                                           C target,
                                                                           @NotNull
                                                                           java.util.Enumeration<S> enumeration,
                                                                           @NotNull
                                                                           FragileTypeConverter<T,? super S> typeConverter,
                                                                           @Nullable
                                                                           T deleteMark)
                                                                    throws TypeConverterException

Add the mapped elements of an enumeration into a collection.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

C - collection type

T - target (mapped) type

S - source type

Parameters:

target - collection where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapMEImpl

@NotNull
static <M extends java.util.Map<? super T,? super S>,T,S> M mapMEImpl(@NotNull
                                                                               M target,
                                                                               @NotNull
                                                                               java.util.Enumeration<S> enumeration,
                                                                               @NotNull
                                                                               FragileTypeConverter<T,? super S> typeConverter,
                                                                               @Nullable
                                                                               T deleteMark)
                                                                        throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The converted values will become keys, pointing to the associated incoming values.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()

mapREImpl

@NotNull
static <M extends java.util.Map<? super S,? super T>,T,S> M mapREImpl(@NotNull
                                                                               M target,
                                                                               @NotNull
                                                                               java.util.Enumeration<S> enumeration,
                                                                               @NotNull
                                                                               FragileTypeConverter<T,? super S> typeConverter,
                                                                               @Nullable
                                                                               T deleteMark)
                                                                        throws TypeConverterException

Add the mapped elements of an enumeration to a map.

The incoming values will become keys, pointing to the associated converted values.

This method allows to discard elements during the mapping.

Note that enumeration is not allowed to be an enumeration of the target collection, otherwise you'll get either a ConcurrentModificationException, or another exception because you are running into an endless loop.

Type Parameters:

M - map type

T - target (mapped) type

S - source type

Parameters:

target - map where the mapped elements are added

enumeration - enumeration providing the source elements

typeConverter - type converter converting the source elements into the mapped elements

deleteMark - special return value of the type converter which means not to copy the result into the target collection. It is compared with reference equality. Often null is a useful choice, only in cases where the target collection may contain null values and the type converter may produce them another mark is necessary.

Returns:

reference to target, allowing to create it directly in the call

Throws:

TypeConverterException - if the conversion fails with an exception, the thrown exception will provide this original exception as TypeConverterException.getException()