code: private static void analyzeType(final Map<Class<?>, LinkedHashMap<String, Type>> generics,
                                      final Class<?> type,
                                      final Map<Class<?>, LinkedHashMap<String, Type>> knownGenerics,
                                      final List<Class<?>> ignoreClasses) {
          Class<?> supertype = type;
          while (true) {
              for (Type iface : supertype.getGenericInterfaces()) {
                  analyzeInterface(generics, knownGenerics, iface, supertype, ignoreClasses);
              }
              final Class next = supertype.getSuperclass();
              if (next == null || Object.class == next || ignoreClasses.contains(next)) {
                  break;
              }
              // possibly provided generics (externally)
              final LinkedHashMap<String, Type> nextGenerics = knownGenerics.containsKey(next)
                      ? knownGenerics.get(next)
                      : analyzeParent(supertype, generics.get(supertype));
              generics.put(next,
                      fillOuterGenerics(next, nextGenerics, knownGenerics));
              supertype = next;
          }
      }
docs: Analyze type hierarchy (all subclasses and interfaces).
  
  @param generics      resolved generics of already analyzed types
  @param knownGenerics type generics known before analysis (some middle class generics are known) and
  possible owner types (types not present in analyzed type hierarchy)
  @param type          class to analyze
  @param ignoreClasses classes to ignore during analysis