docs: public Object convert(String rawString, Type type, Class<?> genericSubType) {
  
          Object converted = null;
  
          if (genericSubType == null && type instanceof ParameterizedType) {
              ParameterizedType pType = (ParameterizedType) type;
              Type[] aTypes = pType.getActualTypeArguments();
              Type genericTypeArg = aTypes.length == 1 ? aTypes[0] : null; //initially only support one type arg
              if (genericTypeArg instanceof Class) { //for the moment we only support a class ... so no type variables; e.g. List<String> is ok but List<T> is not
                  Class<?> genericClassArg = (Class<?>) genericTypeArg;
                  converted = convert(rawString, pType.getRawType(), genericClassArg);
              } else {
                  throw new IllegalArgumentException(Tr.formatMessage(tc, "generic.type.variables.notsupported.CWMCG0018E", type, genericTypeArg));
              }
          } else {
              //first box any primitives
              if (type instanceof Class<?>) {
                  Class<?> clazz = (Class<?>) type;
                  if (clazz.isPrimitive()) {
                      type = ClassUtils.primitiveToWrapper(clazz);
                  }
              }
  
              //do a simple lookup in the map of converters
              ConversionStatus status = simpleConversion(rawString, type, genericSubType);
  
              if (!status.isConverterFound() && type instanceof Class) {
                  Class<?> requestedClazz = (Class<?>) type;
  
                  //try array conversion
                  if (requestedClazz.isArray()) {
                      Class<?> arrayType = requestedClazz.getComponentType();
                      Class<?> conversionType = arrayType;
                      //first convert primitives to wrapper types
                      if (arrayType.isPrimitive()) {
                          conversionType = ClassUtils.primitiveToWrapper(arrayType);
                      }
                      //convert to an array of the wrapper type
                      Object[] wrappedArray = convertArray(rawString, conversionType);// convertArray will throw ConverterNotFoundException if it can't find a converter
  
                      //switch back to the primitive type if required
                      Object value = wrappedArray;
                      if (arrayType.isPrimitive()) {
                          value = toPrimitiveArray(wrappedArray, arrayType);
                      }
  
                      status.setConverted(value);
                  }
  
                  //try implicit converters (e.g. String Constructors)
                  if (!status.isConverterFound()) {
                      status = implicitConverters(rawString, requestedClazz);
                  }
  
                  //try to find any compatible converters
                  if (!status.isConverterFound()) {
                      status = convertCompatible(rawString, requestedClazz);
                  }
  
              }
  
              if (!status.isConverterFound()) {
                  throw new IllegalArgumentException(Tr.formatMessage(tc, "could.not.find.converter.CWMCG0014E", type.getTypeName()));
              }
  
              converted = status.getConverted();
          }
          return converted;
  
      }