org.codehaus.jackson.map.type

## Class TypeFactory

- java.lang.Object
- - org.codehaus.jackson.map.type.TypeFactory

-     public final class TypeFactory
      extends Object

  Class used for creating concrete `JavaType` instances, given various inputs.

  As of Jackson 1.8, usage should be done using instance configured via `ObjectMapper` (and exposed through `DeserializationConfig` and `SerializationConfig`). However, old static-singleton access methods are supported as well; however, using those may cause issues with extension modules that register "type enchancers".

  Typical usage pattern before Jackson 1.8 was to statically import factory methods of this class, to allow convenient instantiation of structured types, especially `Collection` and `Map` types to represent generic types. For example

       mapType(String.class, Integer.class)

  to represent

        Map<String,Integer>

  This is an alternative to using `TypeReference` that would be something like

        new TypeReference<Map<String,Integer>>() { }

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected HierarchicType` | `_cachedArrayListType` Lazily constructed copy of type hierarchy from `ArrayList` to its supertypes.
    `protected HierarchicType` | `_cachedHashMapType` Lazily constructed copy of type hierarchy from `HashMap` to its supertypes.
    `protected TypeModifier[]` | `_modifiers` Registered `TypeModifier`s: objects that can change details of `JavaType` instances factory constructs.
    `protected TypeParser` | `_parser`
    `static TypeFactory` | `instance` Deprecated. As of 1.8, should use a per-ObjectMapper instance instead of global singleton

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `TypeFactory(TypeParser p, TypeModifier[] mods)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected HierarchicType` | `_arrayListSuperInterfaceChain(HierarchicType current)`
    `JavaType` | `_constructType(Type type, TypeBindings context)` Factory method that can be used if type information is passed as Java typing returned from `getGenericXxx` methods (usually for a return or argument type).
    `protected HierarchicType` | `_doFindSuperInterfaceChain(HierarchicType current, Class<?> target)`
    `protected HierarchicType` | `_findSuperClassChain(Type currentType, Class<?> target)`
    `protected HierarchicType` | `_findSuperInterfaceChain(Type currentType, Class<?> target)`
    `protected HierarchicType` | `_findSuperTypeChain(Class<?> subtype, Class<?> supertype)` Helper method used to find inheritance (implements, extends) path between given types, if one exists (caller generally checks before calling this method).
    `protected JavaType` | `_fromArrayType(GenericArrayType type, TypeBindings context)`
    `protected JavaType` | `_fromClass(Class<?> clz, TypeBindings context)`
    `protected JavaType` | `_fromParameterizedClass(Class<?> clz, List<JavaType> paramTypes)` Method used by `TypeParser` when generics-aware version is constructed.
    `protected JavaType` | `_fromParamType(ParameterizedType type, TypeBindings context)` This method deals with parameterized types, that is, first class generic classes.
    `protected JavaType` | `_fromVariable(TypeVariable<?> type, TypeBindings context)`
    `protected JavaType` | `_fromWildcard(WildcardType type, TypeBindings context)`
    `protected HierarchicType` | `_hashMapSuperInterfaceChain(HierarchicType current)`
    `protected JavaType` | `_resolveVariableViaSubTypes(HierarchicType leafType, String variableName, TypeBindings bindings)`
    `protected JavaType` | `_unknownType()`
    `static JavaType` | `arrayType(Class<?> elementType)` Deprecated.
    `static JavaType` | `arrayType(JavaType elementType)` Deprecated.
    `static JavaType` | `collectionType(Class<? extends Collection> collectionType, Class<?> elementType)` Deprecated.
    `static JavaType` | `collectionType(Class<? extends Collection> collectionType, JavaType elementType)` Deprecated.
    `ArrayType` | `constructArrayType(Class<?> elementType)` Method for constructing an `ArrayType`.
    `ArrayType` | `constructArrayType(JavaType elementType)` Method for constructing an `ArrayType`.
    `CollectionLikeType` | `constructCollectionLikeType(Class<?> collectionClass, Class<?> elementClass)` Method for constructing a `CollectionLikeType`.
    `CollectionLikeType` | `constructCollectionLikeType(Class<?> collectionClass, JavaType elementType)` Method for constructing a `CollectionLikeType`.
    `CollectionType` | `constructCollectionType(Class<? extends Collection> collectionClass, Class<?> elementClass)` Method for constructing a `CollectionType`.
    `CollectionType` | `constructCollectionType(Class<? extends Collection> collectionClass, JavaType elementType)` Method for constructing a `CollectionType`.
    `JavaType` | `constructFromCanonical(String canonical)` Factory method for constructing a `JavaType` out of its canonical representation (see `JavaType.toCanonical()`).
    `MapLikeType` | `constructMapLikeType(Class<?> mapClass, Class<?> keyClass, Class<?> valueClass)` Method for constructing a `MapLikeType` instance
    `MapLikeType` | `constructMapLikeType(Class<?> mapClass, JavaType keyType, JavaType valueType)` Method for constructing a `MapLikeType` instance
    `MapType` | `constructMapType(Class<? extends Map> mapClass, Class<?> keyClass, Class<?> valueClass)` Method for constructing a `MapType` instance
    `MapType` | `constructMapType(Class<? extends Map> mapClass, JavaType keyType, JavaType valueType)` Method for constructing a `MapType` instance
    `JavaType` | `constructParametricType(Class<?> parametrized, Class<?>... parameterClasses)` Factory method for constructing `JavaType` that represents a parameterized type.
    `JavaType` | `constructParametricType(Class<?> parametrized, JavaType... parameterTypes)` Factory method for constructing `JavaType` that represents a parameterized type.
    `CollectionLikeType` | `constructRawCollectionLikeType(Class<?> collectionClass)` Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown.
    `CollectionType` | `constructRawCollectionType(Class<? extends Collection> collectionClass)` Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown.
    `MapLikeType` | `constructRawMapLikeType(Class<?> mapClass)` Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown.
    `MapType` | `constructRawMapType(Class<? extends Map> mapClass)` Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown.
    `JavaType` | `constructSimpleType(Class<?> rawType, JavaType[] parameterTypes)` Method for constructing a type instance with specified parameterization.
    `JavaType` | `constructSpecializedType(JavaType baseType, Class<?> subclass)` Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any.
    `JavaType` | `constructType(Type type)`
    `JavaType` | `constructType(Type type, Class<?> context)`
    `JavaType` | `constructType(Type type, JavaType context)`
    `JavaType` | `constructType(TypeReference<?> typeRef)`
    `JavaType` | `constructType(Type type, TypeBindings bindings)`
    `static TypeFactory` | `defaultInstance()` Method used to access the globally shared instance, which has no custom configuration.
    `static JavaType` | `fastSimpleType(Class<?> cls)` Deprecated.
    `static JavaType[]` | `findParameterTypes(Class<?> clz, Class<?> expType)` Deprecated.
    `static JavaType[]` | `findParameterTypes(Class<?> clz, Class<?> expType, TypeBindings bindings)` Deprecated.
    `static JavaType[]` | `findParameterTypes(JavaType type, Class<?> expType)` Deprecated.
    `JavaType[]` | `findTypeParameters(Class<?> clz, Class<?> expType)`
    `JavaType[]` | `findTypeParameters(Class<?> clz, Class<?> expType, TypeBindings bindings)`
    `JavaType[]` | `findTypeParameters(JavaType type, Class<?> expType)` Method that is to figure out actual type parameters that given class binds to generic types defined by given (generic) interface or class.
    `static JavaType` | `fromCanonical(String canonical)`
    `static JavaType` | `fromClass(Class<?> clz)` Deprecated. Use `type(Type)` instead
    `static JavaType` | `fromType(Type type)` Deprecated. Use `type(Type)` instead
    `static JavaType` | `fromTypeReference(TypeReference<?> ref)` Deprecated. Use `type(Type)` instead
    `static JavaType` | `mapType(Class<? extends Map> mapClass, Class<?> keyType, Class<?> valueType)` Deprecated.
    `static JavaType` | `mapType(Class<? extends Map> mapType, JavaType keyType, JavaType valueType)` Deprecated.
    `static JavaType` | `parametricType(Class<?> parametrized, Class<?>... parameterClasses)` Deprecated.
    `static JavaType` | `parametricType(Class<?> parametrized, JavaType... parameterTypes)` Deprecated.
    `static Class<?>` | `rawClass(Type t)`
    `static JavaType` | `specialize(JavaType baseType, Class<?> subclass)` Deprecated.
    `static JavaType` | `type(Type t)` Deprecated.
    `static JavaType` | `type(Type type, Class<?> context)` Deprecated.
    `static JavaType` | `type(Type type, JavaType context)` Deprecated.
    `static JavaType` | `type(TypeReference<?> ref)` Deprecated.
    `static JavaType` | `type(Type type, TypeBindings bindings)` Deprecated.
    `JavaType` | `uncheckedSimpleType(Class<?> cls)` Method that will force construction of a simple type, without trying to check for more specialized types.
    `static JavaType` | `unknownType()` Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type for `java.lang.Object`.
    `TypeFactory` | `withModifier(TypeModifier mod)`

    - ### Methods inherited from class java.lang.Object

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

- - ### Field Detail

    - #### instance

          @Deprecated
          public static final TypeFactory instance

      Deprecated. As of 1.8, should use a per-ObjectMapper instance instead of global singleton
      Globally shared singleton. Should never be accessed directly; non-core code should use per-ObjectMapper instance (via configuration objects). Core Jackson code uses `defaultInstance()` for accessing it.

    - #### _modifiers

          protected final TypeModifier[] _modifiers

      Registered `TypeModifier`s: objects that can change details of `JavaType` instances factory constructs.
      Since:
        1.8

    - #### _parser

          protected final TypeParser _parser

    - #### _cachedHashMapType

          protected HierarchicType _cachedHashMapType

      Lazily constructed copy of type hierarchy from `HashMap` to its supertypes.
      Since:
        1.9

    - #### _cachedArrayListType

          protected HierarchicType _cachedArrayListType

      Lazily constructed copy of type hierarchy from `ArrayList` to its supertypes.
      Since:
        1.9

  - ### Constructor Detail

    - #### TypeFactory

          protected TypeFactory(TypeParser p,
                     TypeModifier[] mods)

  - ### Method Detail

    - #### withModifier

          public TypeFactory withModifier(TypeModifier mod)

    - #### defaultInstance

          public static TypeFactory defaultInstance()

      Method used to access the globally shared instance, which has no custom configuration. Used by `ObjectMapper` to get the default factory when constructed.
      Since:
        1.8

    - #### unknownType

          public static JavaType unknownType()

      Method for constructing a marker type that indicates missing generic type information, which is handled same as simple type for `java.lang.Object`.
      Since:
        1.8

    - #### rawClass

          public static Class<?> rawClass(Type t)

    - #### type

          @Deprecated
          public static JavaType type(Type t)

      Deprecated.

    - #### type

          @Deprecated
          public static JavaType type(Type type,
                                 Class<?> context)

      Deprecated.

    - #### type

          @Deprecated
          public static JavaType type(Type type,
                                 JavaType context)

      Deprecated.

    - #### type

          @Deprecated
          public static JavaType type(Type type,
                                 TypeBindings bindings)

      Deprecated.

    - #### type

          @Deprecated
          public static JavaType type(TypeReference<?> ref)

      Deprecated.

    - #### arrayType

          @Deprecated
          public static JavaType arrayType(Class<?> elementType)

      Deprecated.

    - #### arrayType

          @Deprecated
          public static JavaType arrayType(JavaType elementType)

      Deprecated.

    - #### collectionType

          @Deprecated
          public static JavaType collectionType(Class<? extends Collection> collectionType,
                                           Class<?> elementType)

      Deprecated.

    - #### collectionType

          @Deprecated
          public static JavaType collectionType(Class<? extends Collection> collectionType,
                                           JavaType elementType)

      Deprecated.

    - #### mapType

          @Deprecated
          public static JavaType mapType(Class<? extends Map> mapClass,
                                    Class<?> keyType,
                                    Class<?> valueType)

      Deprecated.

    - #### mapType

          @Deprecated
          public static JavaType mapType(Class<? extends Map> mapType,
                                    JavaType keyType,
                                    JavaType valueType)

      Deprecated.

    - #### parametricType

          @Deprecated
          public static JavaType parametricType(Class<?> parametrized,
                                           Class<?>... parameterClasses)

      Deprecated.

    - #### parametricType

          @Deprecated
          public static JavaType parametricType(Class<?> parametrized,
                                           JavaType... parameterTypes)

      Deprecated.

    - #### fromCanonical

          public static JavaType fromCanonical(String canonical)
                                        throws IllegalArgumentException

      Throws:
        `IllegalArgumentException`

    - #### specialize

          @Deprecated
          public static JavaType specialize(JavaType baseType,
                                       Class<?> subclass)

      Deprecated.

    - #### fastSimpleType

          @Deprecated
          public static JavaType fastSimpleType(Class<?> cls)

      Deprecated.

    - #### findParameterTypes

          @Deprecated
          public static JavaType[] findParameterTypes(Class<?> clz,
                                                 Class<?> expType)

      Deprecated.

    - #### findParameterTypes

          @Deprecated
          public static JavaType[] findParameterTypes(Class<?> clz,
                                                 Class<?> expType,
                                                 TypeBindings bindings)

      Deprecated.

    - #### findParameterTypes

          @Deprecated
          public static JavaType[] findParameterTypes(JavaType type,
                                                 Class<?> expType)

      Deprecated.

    - #### fromClass

          @Deprecated
          public static JavaType fromClass(Class<?> clz)

      Deprecated. Use `type(Type)` instead
      Factory method that can be used if only type information available is of type `Class`. This means that there will not be generic type information due to type erasure, but at least it will be possible to recognize array types and non-typed container types. And for other types (primitives/wrappers, beans), this is all that is needed.

    - #### fromTypeReference

          @Deprecated
          public static JavaType fromTypeReference(TypeReference<?> ref)

      Deprecated. Use `type(Type)` instead
      Factory method that can be used if the full generic type has been passed using `TypeReference`. This only needs to be done if the root type to bind to is generic; but if so, it must be done to get proper typing.

    - #### fromType

          @Deprecated
          public static JavaType fromType(Type type)

      Deprecated. Use `type(Type)` instead
      Factory method that can be used if type information is passed as Java typing returned from `getGenericXxx` methods (usually for a return or argument type).

    - #### constructSpecializedType

          public JavaType constructSpecializedType(JavaType baseType,
                                          Class<?> subclass)

      Factory method for creating a subtype of given base type, as defined by specified subclass; but retaining generic type information if any. Can be used, for example, to get equivalent of "HashMap<String,Integer>" from "Map<String,Integer>" by giving `HashMap.class` as subclass.

    - #### constructFromCanonical

          public JavaType constructFromCanonical(String canonical)
                                          throws IllegalArgumentException

      Factory method for constructing a `JavaType` out of its canonical representation (see `JavaType.toCanonical()`).
      Parameters:
        `canonical` - Canonical string representation of a type
      Throws:
        `IllegalArgumentException` - If canonical representation is malformed, or class that type represents (including its generic parameters) is not found
      Since:
        1.8

    - #### findTypeParameters

          public JavaType[] findTypeParameters(JavaType type,
                                      Class<?> expType)

      Method that is to figure out actual type parameters that given class binds to generic types defined by given (generic) interface or class. This could mean, for example, trying to figure out key and value types for Map implementations.
      Parameters:
        `type` - Sub-type (leaf type) that implements `expType`
      Since:
        1.6

    - #### findTypeParameters

          public JavaType[] findTypeParameters(Class<?> clz,
                                      Class<?> expType)

    - #### findTypeParameters

          public JavaType[] findTypeParameters(Class<?> clz,
                                      Class<?> expType,
                                      TypeBindings bindings)

    - #### constructType

          public JavaType constructType(Type type)

    - #### constructType

          public JavaType constructType(Type type,
                               TypeBindings bindings)

    - #### constructType

          public JavaType constructType(TypeReference<?> typeRef)

    - #### constructType

          public JavaType constructType(Type type,
                               Class<?> context)

    - #### constructType

          public JavaType constructType(Type type,
                               JavaType context)

    - #### _constructType

          public JavaType _constructType(Type type,
                                TypeBindings context)

      Factory method that can be used if type information is passed as Java typing returned from `getGenericXxx` methods (usually for a return or argument type).

    - #### constructArrayType

          public ArrayType constructArrayType(Class<?> elementType)

      Method for constructing an `ArrayType`.

      NOTE: type modifiers are NOT called on array type itself; but are called for element type (and other contained types)

    - #### constructArrayType

          public ArrayType constructArrayType(JavaType elementType)

      Method for constructing an `ArrayType`.

      NOTE: type modifiers are NOT called on array type itself; but are called for contained types.

    - #### constructCollectionType

          public CollectionType constructCollectionType(Class<? extends Collection> collectionClass,
                                               Class<?> elementClass)

      Method for constructing a `CollectionType`.

      NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.

    - #### constructCollectionType

          public CollectionType constructCollectionType(Class<? extends Collection> collectionClass,
                                               JavaType elementType)

      Method for constructing a `CollectionType`.

      NOTE: type modifiers are NOT called on Collection type itself; but are called for contained types.

    - #### constructCollectionLikeType

          public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass,
                                                       Class<?> elementClass)

      Method for constructing a `CollectionLikeType`.

      NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      Since:
        1.8

    - #### constructCollectionLikeType

          public CollectionLikeType constructCollectionLikeType(Class<?> collectionClass,
                                                       JavaType elementType)

      Method for constructing a `CollectionLikeType`.

      NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      Since:
        1.8

    - #### constructMapType

          public MapType constructMapType(Class<? extends Map> mapClass,
                                 JavaType keyType,
                                 JavaType valueType)

      Method for constructing a `MapType` instance

      NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      Since:
        1.8

    - #### constructMapType

          public MapType constructMapType(Class<? extends Map> mapClass,
                                 Class<?> keyClass,
                                 Class<?> valueClass)

      Method for constructing a `MapType` instance

      NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      Since:
        1.8

    - #### constructMapLikeType

          public MapLikeType constructMapLikeType(Class<?> mapClass,
                                         JavaType keyType,
                                         JavaType valueType)

      Method for constructing a `MapLikeType` instance

      NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      Since:
        1.8

    - #### constructMapLikeType

          public MapLikeType constructMapLikeType(Class<?> mapClass,
                                         Class<?> keyClass,
                                         Class<?> valueClass)

      Method for constructing a `MapLikeType` instance

      NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      Since:
        1.8

    - #### constructSimpleType

          public JavaType constructSimpleType(Class<?> rawType,
                                     JavaType[] parameterTypes)

      Method for constructing a type instance with specified parameterization.
      Since:
        1.8

    - #### uncheckedSimpleType

          public JavaType uncheckedSimpleType(Class<?> cls)

      Method that will force construction of a simple type, without trying to check for more specialized types.

      NOTE: no type modifiers are called on type either, so calling this method should only be used if caller really knows what it's doing...

      Since:
        1.8

    - #### constructParametricType

          public JavaType constructParametricType(Class<?> parametrized,
                                         Class<?>... parameterClasses)

      Factory method for constructing `JavaType` that represents a parameterized type. For example, to represent type `List<Set<Integer>>`, you could call

            TypeFactory.parametricType(List.class, Integer.class);

      NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      Since:
        1.5

    - #### constructParametricType

          public JavaType constructParametricType(Class<?> parametrized,
                                         JavaType... parameterTypes)

      Factory method for constructing `JavaType` that represents a parameterized type. For example, to represent type `List<Set<Integer>>`, you could call

            JavaType inner = TypeFactory.parametricType(Set.class, Integer.class);
            TypeFactory.parametricType(List.class, inner);

      NOTE: type modifiers are NOT called on constructed type itself; but are called for contained types.

      Since:
        1.5

    - #### constructRawCollectionType

          public CollectionType constructRawCollectionType(Class<? extends Collection> collectionClass)

      Method that can be used to construct "raw" Collection type; meaning that its parameterization is unknown. This is similar to using `Object.class` parameterization, and is equivalent to calling:

            typeFactory.constructCollectionType(collectionClass, typeFactory.unknownType());

           This method should only be used if parameterization is completely unavailable.

      Since:
        1.9

    - #### constructRawCollectionLikeType

          public CollectionLikeType constructRawCollectionLikeType(Class<?> collectionClass)

      Method that can be used to construct "raw" Collection-like type; meaning that its parameterization is unknown. This is similar to using `Object.class` parameterization, and is equivalent to calling:

            typeFactory.constructCollectionLikeType(collectionClass, typeFactory.unknownType());

           This method should only be used if parameterization is completely unavailable.

      Since:
        1.9

    - #### constructRawMapType

          public MapType constructRawMapType(Class<? extends Map> mapClass)

      Method that can be used to construct "raw" Map type; meaning that its parameterization is unknown. This is similar to using `Object.class` parameterization, and is equivalent to calling:

            typeFactory.constructMapType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());

           This method should only be used if parameterization is completely unavailable.

      Since:
        1.9

    - #### constructRawMapLikeType

          public MapLikeType constructRawMapLikeType(Class<?> mapClass)

      Method that can be used to construct "raw" Map-like type; meaning that its parameterization is unknown. This is similar to using `Object.class` parameterization, and is equivalent to calling:

            typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());

           This method should only be used if parameterization is completely unavailable.

      Since:
        1.9

    - #### _fromClass

          protected JavaType _fromClass(Class<?> clz,
                            TypeBindings context)

      Parameters:
        `context` - Mapping of formal parameter declarations (for generic types) into actual types

    - #### _fromParameterizedClass

          protected JavaType _fromParameterizedClass(Class<?> clz,
                                         List<JavaType> paramTypes)

      Method used by `TypeParser` when generics-aware version is constructed.

    - #### _fromParamType

          protected JavaType _fromParamType(ParameterizedType type,
                                TypeBindings context)

      This method deals with parameterized types, that is, first class generic classes.

      Since version 1.2, this resolves all parameterized types, not just Maps or Collections.

    - #### _fromArrayType

          protected JavaType _fromArrayType(GenericArrayType type,
                                TypeBindings context)

    - #### _fromVariable

          protected JavaType _fromVariable(TypeVariable<?> type,
                               TypeBindings context)

    - #### _fromWildcard

          protected JavaType _fromWildcard(WildcardType type,
                               TypeBindings context)

    - #### _resolveVariableViaSubTypes

          protected JavaType _resolveVariableViaSubTypes(HierarchicType leafType,
                                             String variableName,
                                             TypeBindings bindings)

    - #### _unknownType

          protected JavaType _unknownType()

    - #### _findSuperTypeChain

          protected HierarchicType _findSuperTypeChain(Class<?> subtype,
                                           Class<?> supertype)

      Helper method used to find inheritance (implements, extends) path between given types, if one exists (caller generally checks before calling this method). Returned type represents given subtype, with supertype linkage extending to supertype.

    - #### _findSuperClassChain

          protected HierarchicType _findSuperClassChain(Type currentType,
                                            Class<?> target)

    - #### _findSuperInterfaceChain

          protected HierarchicType _findSuperInterfaceChain(Type currentType,
                                                Class<?> target)

    - #### _doFindSuperInterfaceChain

          protected HierarchicType _doFindSuperInterfaceChain(HierarchicType current,
                                                  Class<?> target)

    - #### _hashMapSuperInterfaceChain

          protected HierarchicType _hashMapSuperInterfaceChain(HierarchicType current)

    - #### _arrayListSuperInterfaceChain

          protected HierarchicType _arrayListSuperInterfaceChain(HierarchicType current)