docs: @SuppressWarnings("unchecked")
    private Converter getConverter(Class<?> valueType)
    {
      Converter c = converters.get(valueType);
      if(c == null) {
        synchronized(converters) {
          if(c == null) {
            if(Types.isKindOf(valueType, Converter.class)) {
              // self-converting value type are instances that contains both data model and converting logic
              registerConverter(valueType, (Class<? extends Converter>)valueType);
            }
            else {
              // not concrete value types, i.e. interface or abstract class, are bound to abstract converters map
              // on the other hand this method got a concrete value type as argument
  
              // lookup an entry into abstract converters map that is super-class for requested value type, that is,
              // requested value type is a kind of a class from abstract converters map
              // then uses that converter instance to create a concrete bind
  
              // as a rational for abstract converters map think of Java time zone
              // time zone instances returned by JRE are not directly implementing TimeZone interface
              // there is an internal abstract base class that cannot be bound to a converter instance
  
              for(Map.Entry<Class<?>, Converter> entries : abstractConverters.entrySet()) {
                if(Types.isKindOf(valueType, entries.getKey())) {
                  registerConverterInstance(valueType, entries.getValue());
                }
              }
            }
            c = converters.get(valueType);
          }
        }
      }
      // at this point converter can still be null
      if(c == null && valueType.isEnum()) {
        return enumsConverter;
      }
      return c;
    }