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

    All Methods Static Methods Concrete Methods
    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()`